diff --git a/core/typescore/approval_delegation.go b/core/typescore/approval_delegation.go
index 03e9aae..202395e 100644
--- a/core/typescore/approval_delegation.go
+++ b/core/typescore/approval_delegation.go
@@ -12,6 +12,7 @@ type ApprovalDelegation struct {
IsActive *bool `gorm:"type:boolean;not null;default:true;column:is_active" json:"is_active" db:"is_active"`
NotifiedDay *bool `gorm:"type:boolean;not null;default:false;column:notified_day" json:"notified_day" db:"notified_day"`
Notified2h *bool `gorm:"type:boolean;not null;default:false;column:notified_2h" json:"notified_2h" db:"notified_2h"`
+ ApprovalID *uint64 `gorm:"type:bigint;index;column:approval_id" json:"approval_id,omitempty" db:"approval_id" mapstructure:"approval_id"`
CreatedAt *time.Time `gorm:"type:timestamp;default:CURRENT_TIMESTAMP;column:created_at" json:"created_at" db:"created_at"`
UpdatedAt *time.Time `gorm:"type:timestamp;default:CURRENT_TIMESTAMP;column:updated_at" json:"updated_at" db:"updated_at"`
diff --git a/service/telegram_service/handlers/approval/absense_delegation.go b/service/telegram_service/handlers/approval/absense_delegation.go
index 1e9059b..b95e6f1 100644
--- a/service/telegram_service/handlers/approval/absense_delegation.go
+++ b/service/telegram_service/handlers/approval/absense_delegation.go
@@ -4,6 +4,7 @@ import (
"bitrix_balancer_api/core/typescore"
"bitrix_balancer_api/core/utilscore"
"bitrix_balancer_api/telegram_service/keyboard"
+ "bitrix_balancer_api/telegram_service/state"
"context"
"fmt"
"regexp"
@@ -17,15 +18,27 @@ import (
// ============================================================
// Делегирование обязанностей на время отсутствия (отгул/отпуск/
// больничный). Включается флагом ApprovalTopic.AllowDelegationSelection
-// (тот же паттерн, что AllowObserverSelection) — см. patch к
-// ApprovalTopic и к continueFlowAfterInput в конце ответа.
+// (тот же паттерн, что AllowObserverSelection) — см. DELEGATION_PATCHES.txt.
+//
+// 🩹 Жизненный цикл делегирования (важное отличие от первой версии):
+// запись ApprovalDelegation создаётся СРАЗУ при подаче заявки на
+// отсутствие, но НЕАКТИВНОЙ (IsActive=false) — см. createPendingDelegation,
+// вызывается из submitApproval. Активируется она ТОЛЬКО когда сама заявка
+// будет полностью согласована — activatePendingDelegation, вызывается из
+// processNextStepOrComplete в момент финального approved. Если заявку
+// впоследствии отзовут — deactivatePendingDelegation (вызывается из
+// performActualRevoke) выключает делегирование обратно, независимо от
+// того, успело оно активироваться или нет.
+//
+// Здесь, в диалоге с ботом, происходит только ВЫБОР делегата — реальная
+// запись в БД появляется позже, вместе с самой заявкой.
// ============================================================
// showDelegationChoice — экран "делегировать все обязанности?" (Да/Нет).
func (h *Handler) showDelegationChoice(bot *tgbotapi.BotAPI, chatID int64, telegramID int64) {
text := "🔁 Делегировать все обязанности по согласованию на другого человека на время вашего отсутствия?\n\n" +
- "Если согласитесь — все заявки, которые сейчас или ещё придут к вам на согласование, " +
- "будут автоматически передаваться выбранному человеку до конца периода отсутствия."
+ "Делегирование начнёт действовать только после того, как эта заявка будет согласована, " +
+ "и автоматически отменится, если заявку впоследствии отзовут."
msg := tgbotapi.NewMessage(chatID, text)
msg.ParseMode = "HTML"
@@ -107,6 +120,13 @@ func (h *Handler) HandleDelegateSelectionPageCallback(bot *tgbotapi.BotAPI, cq *
}
// HandleDelegateSelectionCallback — пользователь выбрал конкретного делегата.
+//
+// 🩹 ВАЖНО: здесь запись в ApprovalDelegation больше НЕ создаётся. Мы
+// только запоминаем выбор в flowState.SelectedDelegateID — реальная
+// (неактивная) запись появится в submitApproval/createPendingDelegation,
+// когда заявка будет фактически отправлена (это происходит сразу вслед
+// за этим шагом в том же диалоге, так что 30-минутный TTL состояния в
+// Redis не успевает истечь).
func (h *Handler) HandleDelegateSelectionCallback(bot *tgbotapi.BotAPI, cq *tgbotapi.CallbackQuery, delegateID uint64) {
ctx := context.Background()
chatID := cq.Message.Chat.ID
@@ -120,87 +140,33 @@ func (h *Handler) HandleDelegateSelectionCallback(bot *tgbotapi.BotAPI, cq *tgbo
return
}
- me, err := h.ipc.Database.User.GetUserByTelegramIDDB(ctx, telegramID)
- if err != nil || me == nil || me.ID == nil {
- sendText(bot, chatID, "⚠️ Пользователь не найден.")
- return
- }
-
delegate, err := h.ipc.Database.User.GetUserByIDDB(ctx, delegateID)
if err != nil || delegate == nil {
sendText(bot, chatID, "⚠️ Сотрудник не найден.")
return
}
- // ValidUntil обязателен в схеме (not null) — определяем его из дат,
- // введённых сотрудником на предыдущем шаге. Тот же терпимый к
- // опечаткам разбор дат, что в scheduler/daily_reminder.go (там —
- // уже готовая заявка, тут — ещё не отправленный flowState.Collected,
- // но логика разбора идентична; продублирована намеренно, чтобы не
- // тянуть в этот пакет зависимость от scheduler).
- validUntil, datesFound := delegationValidUntil(flowState.Collected)
- if !datesFound {
- logrus.Warnf("HandleDelegateSelectionCallback: не удалось определить дату окончания отсутствия для userID=%d delegate=%d — используется запасной срок 30 дней", *me.ID, delegateID)
- }
-
- // Поиск делегата в processNextStepOrComplete/handleDecision матчит
- // строго по конкретному TopicID ЛИБО конкретному CategoryID — запись
- // с обоими NULL ("на всё сразу") никогда бы не нашлась. Поэтому
- // создаём отдельную запись на каждую активную категорию согласований.
- categories, _, err := h.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, typescore.ListDbOptions{
- Filtering: &typescore.ApprovalTopicCategory{IsActive: utilscore.PointerToBool(true)},
- })
- if err != nil {
- logrus.Errorf("HandleDelegateSelectionCallback: GetApprovalTopicCategoriesListDB err=%v", err)
- sendText(bot, chatID, "⚠️ Ошибка при настройке делегирования.")
- return
- }
-
- isActive := true
- notifiedFalse := false
- created := 0
- for _, cat := range categories {
- if cat.ID == nil {
- continue
- }
- catID := *cat.ID
- delegation := &typescore.ApprovalDelegation{
- DelegatorID: me.ID,
- DelegateID: delegate.ID,
- CategoryID: &catID,
- ValidUntil: &validUntil,
- IsActive: &isActive,
- NotifiedDay: ¬ifiedFalse,
- Notified2h: ¬ifiedFalse,
- }
- if _, _, err := h.ipc.Database.ApprovalDelegation.CreateApprovalDelegationDB(ctx, nil, delegation); err != nil {
- logrus.Errorf("HandleDelegateSelectionCallback: CreateApprovalDelegationDB categoryID=%d err=%v", catID, err)
- continue
- }
- created++
- }
-
- delegateName := "—"
- if delegate.FullName != nil {
- delegateName = *delegate.FullName
- }
-
flowState.AwaitDelegateSelection = false
flowState.DelegationSelectionDone = true
flowState.SelectedDelegateID = delegateID
h.States.Set(ctx, telegramID, flowState) //nolint:errcheck
- if created == 0 {
- sendText(bot, chatID, "⚠️ Не удалось настроить делегирование. Обязанности остаются на вас.")
- } else {
- sendText(bot, chatID, fmt.Sprintf(
- "🔁 Обязанности по согласованию делегированы\n\n"+
- "👤 Кому: %s\n"+
- "📅 До: %s",
- delegateName, validUntil.Format("02.01.2006"),
- ))
+ delegateName := "—"
+ if delegate.FullName != nil {
+ delegateName = *delegate.FullName
}
+ // Дата — только для информации в этом сообщении, реальное значение
+ // пересчитывается и сохраняется в createPendingDelegation.
+ validUntil, _ := delegationValidUntil(flowState.Collected)
+
+ sendText(bot, chatID, fmt.Sprintf(
+ "🔁 Обязанности будут делегированы: %s\n"+
+ "📅 Ориентировочно до: %s\n\n"+
+ "Начнёт действовать после согласования этой заявки и отменится, если её впоследствии отзовут.",
+ delegateName, validUntil.Format("02.01.2006"),
+ ))
+
h.continueFlowAfterInput(bot, ctx, chatID, telegramID, flowState)
}
@@ -231,6 +197,139 @@ func (h *Handler) getAvailableDelegateCandidates(ctx context.Context, telegramID
return result, nil
}
+// ============================================================
+// Создание / активация / деактивация делегирования, привязанного к
+// конкретной заявке (approval_id — см. DELEGATION_PATCHES.txt).
+// ============================================================
+
+// createPendingDelegation вызывается из submitApproval сразу после
+// создания заявки. Создаёт по одной НЕАКТИВНОЙ записи ApprovalDelegation
+// на каждую активную категорию согласований (поиск делегата в
+// processNextStepOrComplete/handleDecision матчит строго по конкретному
+// TopicID либо конкретному CategoryID — запись "на всё сразу" с обоими
+// NULL никогда бы не нашлась).
+func (h *Handler) createPendingDelegation(ctx context.Context, initiator *typescore.User, flowState *state.ApprovalFlowState, approval *typescore.Approval) {
+ if flowState.SelectedDelegateID == 0 {
+ return
+ }
+ if initiator == nil || initiator.ID == nil || approval == nil || approval.ID == nil {
+ return
+ }
+
+ delegate, err := h.ipc.Database.User.GetUserByIDDB(ctx, flowState.SelectedDelegateID)
+ if err != nil || delegate == nil || delegate.ID == nil {
+ logrus.Errorf("createPendingDelegation: delegate not found id=%d err=%v", flowState.SelectedDelegateID, err)
+ return
+ }
+
+ validUntil, datesFound := delegationValidUntil(flowState.Collected)
+ if !datesFound {
+ logrus.Warnf("createPendingDelegation: не удалось определить дату окончания отсутствия approvalID=%d — используется запасной срок 30 дней", *approval.ID)
+ }
+
+ categories, _, err := h.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.ApprovalTopicCategory{IsActive: utilscore.PointerToBool(true)},
+ })
+ if err != nil {
+ logrus.Errorf("createPendingDelegation: GetApprovalTopicCategoriesListDB err=%v", err)
+ return
+ }
+
+ inactive := false
+ notifiedFalse := false
+ created := 0
+ for _, cat := range categories {
+ if cat.ID == nil {
+ continue
+ }
+ catID := *cat.ID
+ delegation := &typescore.ApprovalDelegation{
+ DelegatorID: initiator.ID,
+ DelegateID: delegate.ID,
+ CategoryID: &catID,
+ ApprovalID: approval.ID,
+ ValidUntil: &validUntil,
+ IsActive: &inactive, // включится только после одобрения заявки
+ NotifiedDay: ¬ifiedFalse,
+ Notified2h: ¬ifiedFalse,
+ }
+ if _, _, err := h.ipc.Database.ApprovalDelegation.CreateApprovalDelegationDB(ctx, nil, delegation); err != nil {
+ logrus.Errorf("createPendingDelegation: CreateApprovalDelegationDB categoryID=%d approvalID=%d err=%v", catID, *approval.ID, err)
+ continue
+ }
+ created++
+ }
+
+ logrus.Infof("createPendingDelegation: создано неактивных делегирований=%d approvalID=%d delegatorID=%d delegateID=%d",
+ created, *approval.ID, *initiator.ID, *delegate.ID)
+}
+
+// activatePendingDelegation включает делегирование, привязанное к этой
+// заявке (см. createPendingDelegation), в момент её полного одобрения.
+// Вызывается из processNextStepOrComplete строго в ветке финального
+// approved (не при передаче на следующий шаг).
+func (h *Handler) activatePendingDelegation(ctx context.Context, approval *typescore.Approval) {
+ if approval == nil || approval.ID == nil {
+ return
+ }
+
+ delegations, _, err := h.ipc.Database.ApprovalDelegation.GetApprovalDelegationsListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.ApprovalDelegation{ApprovalID: approval.ID},
+ })
+ if err != nil {
+ logrus.Errorf("activatePendingDelegation: GetApprovalDelegationsListDB approvalID=%d err=%v", *approval.ID, err)
+ return
+ }
+ if len(delegations) == 0 {
+ return // делегирование при подаче этой заявки не настраивалось
+ }
+
+ active := true
+ for _, d := range delegations {
+ d.IsActive = &active
+ if _, _, err := h.ipc.Database.ApprovalDelegation.UpdateApprovalDelegationDB(ctx, nil, d); err != nil {
+ logrus.Errorf("activatePendingDelegation: UpdateApprovalDelegationDB id=%v err=%v", d.ID, err)
+ }
+ }
+ logrus.Infof("activatePendingDelegation: активировано делегирований=%d approvalID=%d", len(delegations), *approval.ID)
+}
+
+// deactivatePendingDelegation отменяет делегирование, привязанное к этой
+// заявке, при её отзыве — независимо от того, успело оно активироваться
+// (заявка уже была одобрена) или ещё оставалось неактивным (заявку
+// отозвали прямо во время согласования). Вызывается из performActualRevoke.
+func (h *Handler) deactivatePendingDelegation(ctx context.Context, approval *typescore.Approval) {
+ if approval == nil || approval.ID == nil {
+ return
+ }
+
+ delegations, _, err := h.ipc.Database.ApprovalDelegation.GetApprovalDelegationsListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.ApprovalDelegation{ApprovalID: approval.ID},
+ })
+ if err != nil {
+ logrus.Errorf("deactivatePendingDelegation: GetApprovalDelegationsListDB approvalID=%d err=%v", *approval.ID, err)
+ return
+ }
+ if len(delegations) == 0 {
+ return
+ }
+
+ inactive := false
+ changed := 0
+ for _, d := range delegations {
+ if d.IsActive != nil && !*d.IsActive {
+ continue // уже неактивно
+ }
+ d.IsActive = &inactive
+ if _, _, err := h.ipc.Database.ApprovalDelegation.UpdateApprovalDelegationDB(ctx, nil, d); err != nil {
+ logrus.Errorf("deactivatePendingDelegation: UpdateApprovalDelegationDB id=%v err=%v", d.ID, err)
+ continue
+ }
+ changed++
+ }
+ logrus.Infof("deactivatePendingDelegation: отменено делегирований=%d approvalID=%d", changed, *approval.ID)
+}
+
// ============================================================
// Разбор дат из flowState.Collected — тот же терпимый к опечаткам
// подход, что в scheduler/daily_reminder.go (getAbsentEmployeesToday),
diff --git a/service/telegram_service/handlers/approval/handler.go b/service/telegram_service/handlers/approval/handler.go
index f8be6ac..ab9cd0f 100644
--- a/service/telegram_service/handlers/approval/handler.go
+++ b/service/telegram_service/handlers/approval/handler.go
@@ -409,6 +409,8 @@ func (h *Handler) performActualRevoke(
return
}
+ h.deactivatePendingDelegation(ctx, approval)
+
h.handleRevokeCancellationTask(bot, ctx, approval)
revokerName := "—"
diff --git a/service/telegram_service/handlers/approval/handler_decision.go b/service/telegram_service/handlers/approval/handler_decision.go
index 58783f6..7e2582c 100644
--- a/service/telegram_service/handlers/approval/handler_decision.go
+++ b/service/telegram_service/handlers/approval/handler_decision.go
@@ -205,6 +205,8 @@ func (h *Handler) processNextStepOrComplete(bot *tgbotapi.BotAPI, ctx context.Co
approval.Status = &approvedStatus
h.ipc.Database.Approval.UpdateApprovalDB(ctx, nil, approval) //nolint:errcheck
+ h.activatePendingDelegation(ctx, approval)
+
lastStepIsDelegate := currentStep.ApproverID != nil && *currentStep.ApproverID != actualExecutorID
if currentStep.ApproverID != nil {
diff --git a/service/telegram_service/handlers/approval/helper.go b/service/telegram_service/handlers/approval/helper.go
index 0c00c92..ebfdade 100644
--- a/service/telegram_service/handlers/approval/helper.go
+++ b/service/telegram_service/handlers/approval/helper.go
@@ -129,6 +129,8 @@ func (h *Handler) submitApproval(ctx context.Context, bot *tgbotapi.BotAPI, tele
}
created.Files = files
+ h.createPendingDelegation(ctx, initiator, flowState, created)
+
var approvers []*typescore.User
// Если выбран первый согласующий по роли — он будет шагом 0
@@ -173,7 +175,6 @@ func (h *Handler) submitApproval(ctx context.Context, bot *tgbotapi.BotAPI, tele
return nil, fmt.Errorf("⚠️ Для вас в данной теме не настроены согласующие. Пожалуйста, обратитесь к руководителю с просьбой о настройке прав в системе согласований")
}
- // === НОВЫЙ БЛОК: ГРУППИРОВКА ПО ПРИОРИТЕТУ ===
priorityGroups := make(map[int][]*typescore.User)
if approvalTopic.ApprovalMode != nil {
diff --git a/service/telegram_service/scheduler/daily_reminder.go b/service/telegram_service/scheduler/daily_reminder.go
index 5822714..97fe30c 100644
--- a/service/telegram_service/scheduler/daily_reminder.go
+++ b/service/telegram_service/scheduler/daily_reminder.go
@@ -25,10 +25,24 @@ func NewDailyReminder(ipc *types.InternalProviderControl) *DailyReminder {
return &DailyReminder{ipc: ipc}
}
+// Start запускает планировщик ежедневных напоминаний
func (dr *DailyReminder) Start() {
+ logrus.Infof("DailyReminder: Start() вызван — планировщик запускается")
+
+ // 🧪 ВРЕМЕННО ДЛЯ ТЕСТА — отправляет сводку сразу при старте (не ждёт
+ // 9:00 МСК), в отдельной горутине, чтобы не блокировать запуск
+ // остального сервиса. Благодаря фильтру testOnlyTelegramID в
+ // sendReminders() уйдёт только на ваш тестовый Telegram ID, никто
+ // больше ничего не получит. Удалите эти три строки вместе с фильтром
+ // в sendReminders(), когда закончите тестировать — иначе при каждом
+ // перезапуске сервиса будет уходить лишняя внеплановая отправка.
+ logrus.Infof("DailyReminder: 🧪 немедленный тестовый запуск sendReminders() при старте")
+ go dr.sendReminders()
+
go dr.scheduleLoop()
}
+// scheduleLoop бесконечный цикл, который ждет 9:00 МСК каждый день
func (dr *DailyReminder) scheduleLoop() {
mskLocation, err := time.LoadLocation("Europe/Moscow")
if err != nil {
@@ -39,8 +53,10 @@ func (dr *DailyReminder) scheduleLoop() {
for {
now := time.Now().In(mskLocation)
+ // Вычисляем следующее 9:00 МСК
next := time.Date(now.Year(), now.Month(), now.Day(), 9, 0, 0, 0, mskLocation)
+ // Если сегодня уже прошло 9:00, планируем на завтра
if now.After(next) {
next = next.AddDate(0, 0, 1)
}
@@ -51,23 +67,31 @@ func (dr *DailyReminder) scheduleLoop() {
logrus.Infof("DailyReminder: следующее напоминание запланировано на %s (через %v)",
next.Format("02.01.2006 15:04 MSK"), duration.Round(time.Second))
+ // Ждем до следующего 9:00
time.Sleep(duration)
+ // Отправляем напоминания
dr.sendReminders()
}
}
+// skipWeekends переносит дату на ближайший будний день,
+// если она выпадает на субботу или воскресенье
func (dr *DailyReminder) skipWeekends(t time.Time) time.Time {
switch t.Weekday() {
case time.Saturday:
return t.AddDate(0, 0, 2)
case time.Sunday:
+ // Воскресенье → понедельник (+1 день)
return t.AddDate(0, 0, 1)
}
return t
}
+// sendReminders отправляет напоминания всем пользователям
func (dr *DailyReminder) sendReminders() {
+ logrus.Infof("DailyReminder: sendReminders() запущен")
+
ctx := context.Background()
bot := dr.ipc.TGBotClient.Bot()
@@ -76,24 +100,34 @@ func (dr *DailyReminder) sendReminders() {
logrus.Errorf("DailyReminder: не удалось загрузить часовой пояс МСК: %v", err)
mskLocation = time.FixedZone("MSK", 3*3600)
}
+ logrus.Infof("DailyReminder: сегодняшняя дата (МСК) = %s", time.Now().In(mskLocation).Format("02.01.2006"))
+ // Получаем всех активных пользователей
users, _, err := dr.ipc.Database.User.GetUsersListDB(ctx, typescore.ListDbOptions{})
if err != nil {
logrus.Errorf("DailyReminder: GetUsersListDB err=%v", err)
return
}
+ logrus.Infof("DailyReminder: получено пользователей из БД: %d", len(users))
+ // 🆕 Список отсутствующих сегодня считаем ОДИН раз на всю рассылку —
+ // это общая для всех информация, а не персональная, поэтому нет смысла
+ // пересчитывать её в цикле для каждого сотрудника отдельно.
absentToday := dr.getAbsentEmployeesToday(ctx, mskLocation)
logrus.Infof("DailyReminder: начинаем отправку напоминаний для %d пользователей (отсутствующих сегодня: %d)",
len(users), len(absentToday))
- // TODO: удалить после тестов
+ // 🧪 ВРЕМЕННО ДЛЯ ТЕСТА — рассылка только на один Telegram ID.
+ // Удалите эту константу и проверку ниже (тоже помечена 🧪) перед тем,
+ // как снова выкатывать рассылку на всех сотрудников.
const testOnlyTelegramID int64 = 493325176
+ logrus.Infof("DailyReminder: 🧪 активен тестовый фильтр — рассылка пойдёт только на telegram_id=%d", testOnlyTelegramID)
sentCount := 0
for _, user := range users {
if user.TelegramID == nil || user.ID == nil {
+ logrus.Debugf("DailyReminder: пропуск пользователя без TelegramID/ID (user=%+v)", user)
continue
}
@@ -102,16 +136,25 @@ func (dr *DailyReminder) sendReminders() {
continue
}
- if dr.sendReminderToUser(bot, ctx, user, absentToday) {
+ logrus.Infof("DailyReminder: 🧪 найден тестовый пользователь userID=%d telegramID=%d — формируем сводку",
+ *user.ID, *user.TelegramID)
+
+ sent := dr.sendReminderToUser(bot, ctx, user, absentToday)
+ logrus.Infof("DailyReminder: 🧪 результат отправки тестовому пользователю telegramID=%d: sent=%v",
+ *user.TelegramID, sent)
+ if sent {
sentCount++
}
+ // Небольшая задержка, чтобы не перегружать Telegram API
time.Sleep(100 * time.Millisecond)
}
logrus.Infof("DailyReminder: отправлено напоминаний: %d из %d", sentCount, len(users))
}
+// sendReminderToUser отправляет напоминание конкретному пользователю
+// Возвращает true, если сообщение было отправлено
func (dr *DailyReminder) sendReminderToUser(bot *tgbotapi.BotAPI, ctx context.Context, user *typescore.User, absentToday []AbsentEmployeeInfo) bool {
userID := *user.ID
telegramID := *user.TelegramID
@@ -127,6 +170,7 @@ func (dr *DailyReminder) sendReminderToUser(bot *tgbotapi.BotAPI, ctx context.Co
}
revisionsCount := len(revisions)
+ // 2. Задачи к исполнению (роль исполнителя)
tasks, _, err := dr.ipc.Database.ApprovalTasks.GetApprovalTasksListDB(ctx, typescore.ListDbOptions{
Filtering: &typescore.ApprovalTask{
ExecutorID: &userID,
@@ -148,6 +192,7 @@ func (dr *DailyReminder) sendReminderToUser(bot *tgbotapi.BotAPI, ctx context.Co
logrus.Errorf("DailyReminder: GetApprovalStepsListDB for user=%d err=%v", userID, err)
}
+ // Также проверяем дополнительные согласования
additionalApprovers, _, err := dr.ipc.Database.ApprovalAdditionalApprover.GetApprovalAdditionalApproversListDB(ctx, typescore.ListDbOptions{
Filtering: &typescore.ApprovalAdditionalApprover{
ApproverID: &userID,
@@ -158,11 +203,20 @@ func (dr *DailyReminder) sendReminderToUser(bot *tgbotapi.BotAPI, ctx context.Co
logrus.Errorf("DailyReminder: GetApprovalAdditionalApproversListDB for user=%d err=%v", userID, err)
}
+ // 🚀 Считаем только те шаги/доп. согласующих, у которых сама заявка в статусе pending
approvalsCount := dr.countPendingApprovals(ctx, steps, additionalApprovers)
hasPersonalItems := revisionsCount > 0 || tasksCount > 0 || approvalsCount > 0
+ logrus.Infof("DailyReminder: userID=%d telegramID=%d — revisions=%d tasks=%d approvals=%d hasPersonalItems=%v absentTodayCount=%d",
+ userID, telegramID, revisionsCount, tasksCount, approvalsCount, hasPersonalItems, len(absentToday))
+
+ // 🆕 Раньше: если сообщить нечего — не отправляем совсем. Теперь
+ // список отсутствующих сегодня — самостоятельный повод прислать
+ // сводку, даже если лично у сотрудника пусто (по вашему решению —
+ // присылаем всем каждое утро, пока список непустой).
if !hasPersonalItems && len(absentToday) == 0 {
+ logrus.Infof("DailyReminder: userID=%d telegramID=%d — нечего сообщить (нет личных пунктов и список отсутствующих пуст), сообщение НЕ отправляется", userID, telegramID)
return false
}
@@ -197,6 +251,8 @@ func (dr *DailyReminder) sendReminderToUser(bot *tgbotapi.BotAPI, ctx context.Co
msg := tgbotapi.NewMessage(telegramID, text)
msg.ParseMode = "HTML"
+ // Кнопки имеют смысл только если есть личные пункты для перехода —
+ // список отсутствующих никуда вести не должен.
if hasPersonalItems {
msg.ReplyMarkup = keyboard.BuildDailyReminderKeyboard(
revisionsCount > 0,
@@ -210,9 +266,13 @@ func (dr *DailyReminder) sendReminderToUser(bot *tgbotapi.BotAPI, ctx context.Co
return false
}
+ logrus.Infof("DailyReminder: сообщение успешно отправлено telegramID=%d (длина текста=%d символов)", telegramID, len(text))
+
return true
}
+// countPendingApprovals считает количество заявок со статусом "pending"
+// из списка шагов и дополнительных согласующих
func (dr *DailyReminder) countPendingApprovals(
ctx context.Context,
steps []*typescore.ApprovalStep,
@@ -236,6 +296,7 @@ func (dr *DailyReminder) countPendingApprovals(
return 0
}
+ // Получаем все заявки одним запросом и фильтруем по статусу pending
count := 0
for approvalID := range approvalIDs {
id := approvalID
@@ -251,6 +312,30 @@ func (dr *DailyReminder) countPendingApprovals(
return count
}
+// ============================================================
+// 🆕 "Кто сегодня отсутствует" — отгул/больничный/отпуск
+// ============================================================
+
+// absenceMetadata — то, что реально надёжно есть в metadata.extra у
+// заявок категорий "Отгул"/"Больничный"/"Отпуск". AbsenceType — маркер
+// того, что это вообще заявка на отсутствие (у остальных категорий
+// этого поля просто нет). TimeType говорит "весь день" или "частично",
+// но САМИ ДАТЫ отдельного структурированного поля не имеют — сотрудник
+// вводит их свободным текстом на последнем шаге дерева, попадает это в
+// Approval.Content. Реальные примеры того, что там оказывается:
+//
+// "11.07.2026-24.07.2026" (диапазон дат)
+// "24,07.2026 и 27.07.2026" (список дат, ЕЩЁ и с опечаткой —
+// запятая вместо точки)
+// "21.07.2026 с 9:00 по 11:00" (один день + время)
+// "22.07.2026" (просто один день)
+//
+// Единого формата нет и не будет, поэтому ниже — терпимый к опечаткам
+// разбор через regexp (вытаскиваем все даты/времена, какие найдутся),
+// а не попытка сопоставить точный шаблон под duration_type. Это
+// осознанный компромисс: часть экзотических формулировок сотрудников
+// распознана не будет, и заявка просто тихо не попадёт в сводку —
+// лучше так, чем показать в сводке неверную дату.
type absenceMetadata struct {
Extra struct {
TimeType string `json:"time_type"`
@@ -261,17 +346,30 @@ type absenceMetadata struct {
type AbsentEmployeeInfo struct {
Name string
TimeDescription string
- Contact string
+ // 🆕 Contact — кому обращаться по срочным вопросам: делегату, если
+ // сотрудник делегировал обязанности при уходе (см.
+ // handlers/approval/delegation.go), иначе — самому сотруднику.
+ Contact string
}
+// Даты: ДД.MM.ГГГГ, но день от месяца иногда отделён запятой вместо
+// точки (реальная опечатка сотрудника) — поэтому [.,], а не просто ".".
var absenceDateRe = regexp.MustCompile(`(\d{1,2})[.,](\d{1,2})\.(\d{4})`)
+// Время: строго через двоеточие (9:00, 11:00) — специально НЕ через
+// точку, чтобы не перепутать с датами (21.07 иначе тоже подошло бы
+// под "число.число").
var absenceTimeRe = regexp.MustCompile(`(\d{1,2}):(\d{2}).*?(\d{1,2}):(\d{2})`)
+// getAbsentEmployeesToday возвращает всех сотрудников, чьи одобренные
+// заявки на отгул/больничный/отпуск покрывают сегодняшний день.
func (dr *DailyReminder) getAbsentEmployeesToday(ctx context.Context, mskLocation *time.Location) []AbsentEmployeeInfo {
today := time.Now().In(mskLocation)
todayY, todayM, todayD := today.Date()
+ // Без фильтра по InitiatorID — одним запросом получаем все одобренные
+ // заявки компании и дальше фильтруем в памяти. Так один раз на всю
+ // рассылку, а не по запросу на каждого сотрудника.
approvals, _, err := dr.ipc.Database.Approval.GetApprovalsListDB(ctx, typescore.ListDbOptions{
Filtering: &typescore.Approval{
Status: utilscore.PointerToString("approved"),
@@ -281,37 +379,59 @@ func (dr *DailyReminder) getAbsentEmployeesToday(ctx context.Context, mskLocatio
logrus.Errorf("DailyReminder: getAbsentEmployeesToday: GetApprovalsListDB err=%v", err)
return nil
}
+ logrus.Infof("DailyReminder: getAbsentEmployeesToday: заявок со статусом approved найдено: %d (сегодня %04d-%02d-%02d)",
+ len(approvals), todayY, todayM, todayD)
seenUsers := make(map[uint64]bool)
var result []AbsentEmployeeInfo
for _, approval := range approvals {
+ approvalID := derefApprovalID(approval)
+
if approval.Metadata == nil || *approval.Metadata == "" || approval.Content == nil {
+ logrus.Infof("DailyReminder: заявка #%d пропущена — нет Metadata или Content", approvalID)
continue
}
var meta absenceMetadata
if err := json.Unmarshal([]byte(*approval.Metadata), &meta); err != nil {
+ logrus.Warnf("DailyReminder: заявка #%d — не удалось распарсить Metadata как JSON: %v (metadata=%q)",
+ approvalID, err, *approval.Metadata)
continue
}
if meta.Extra.AbsenceType == "" {
+ // Не заявка на отсутствие — это поле есть только у
+ // отгула/больничного/отпуска.
+ logrus.Infof("DailyReminder: заявка #%d пропущена — metadata.extra.absence_type пустой (не тема отсутствия), metadata=%q",
+ approvalID, *approval.Metadata)
continue
}
+ logrus.Infof("DailyReminder: заявка #%d — absence_type=%q time_type=%q content=%q",
+ approvalID, meta.Extra.AbsenceType, meta.Extra.TimeType, *approval.Content)
- if approval.InitiatorID == nil || seenUsers[*approval.InitiatorID] {
+ if approval.InitiatorID == nil {
+ logrus.Warnf("DailyReminder: заявка #%d пропущена — InitiatorID nil", approvalID)
+ continue
+ }
+ if seenUsers[*approval.InitiatorID] {
+ logrus.Infof("DailyReminder: заявка #%d пропущена — по этому инициатору (userID=%d) уже есть запись в сводке", approvalID, *approval.InitiatorID)
continue
}
dates := parseAbsenceDates(*approval.Content)
if len(dates) == 0 {
- logrus.Warnf("DailyReminder: не удалось разобрать даты в content заявки #%d: %q",
- derefApprovalID(approval), *approval.Content)
+ logrus.Warnf("DailyReminder: заявка #%d — не удалось разобрать даты в content: %q",
+ approvalID, *approval.Content)
continue
}
+ logrus.Infof("DailyReminder: заявка #%d — распознанные даты: %v", approvalID, dates)
if !absenceCoversDate(dates, *approval.Content, todayY, todayM, todayD) {
+ logrus.Infof("DailyReminder: заявка #%d пропущена — распознанные даты не покрывают сегодня (%04d-%02d-%02d)",
+ approvalID, todayY, todayM, todayD)
continue
}
+ logrus.Infof("DailyReminder: заявка #%d — покрывает сегодня, добавляем в сводку", approvalID)
name := "—"
if approval.Initiator != nil && approval.Initiator.FullName != nil {
@@ -323,6 +443,11 @@ func (dr *DailyReminder) getAbsentEmployeesToday(ctx context.Context, mskLocatio
}
}
+ // 🆕 Формулировка зависит от категории отсутствия: у отгула
+ // показываем время (или "весь день"), у отпуска/больничного —
+ // дату, ДО которой человек отсутствует (последняя из найденных
+ // дат — для диапазона это конец диапазона, для списка вроде
+ // "24.07 и 27.07" — последний день из списка).
var timeDescription string
switch meta.Extra.AbsenceType {
case "timeoff":
@@ -343,6 +468,12 @@ func (dr *DailyReminder) getAbsentEmployeesToday(ctx context.Context, mskLocatio
timeDescription = "отсутствует"
}
+ // 🆕 Контакт по срочным вопросам: если у сотрудника есть активное
+ // делегирование (см. handlers/approval/delegation.go), показываем
+ // делегата, иначе — самого сотрудника. ValidUntil проверяем
+ // дополнительно как подстраховку — на случай, если задача,
+ // отвечающая за деактивацию просроченных делегирований (см.
+ // NotifiedDay/Notified2h в ApprovalDelegation), ещё не отработала.
contact := name
if delegations, _, dErr := dr.ipc.Database.ApprovalDelegation.GetApprovalDelegationsListDB(ctx, typescore.ListDbOptions{
Filtering: &typescore.ApprovalDelegation{
@@ -374,6 +505,8 @@ func (dr *DailyReminder) getAbsentEmployeesToday(ctx context.Context, mskLocatio
})
}
+ logrus.Infof("DailyReminder: getAbsentEmployeesToday: итоговый список отсутствующих сегодня (%d): %+v", len(result), result)
+
return result
}
@@ -383,6 +516,9 @@ func derefApprovalID(a *typescore.Approval) uint64 {
}
return *a.ID
}
+
+// parseAbsenceDates вытаскивает все даты вида ДД.MM.ГГГГ из произвольного
+// текста, независимо от того, что вокруг них написано.
func parseAbsenceDates(content string) []time.Time {
matches := absenceDateRe.FindAllStringSubmatch(content, -1)
var dates []time.Time
@@ -401,6 +537,8 @@ func parseAbsenceDates(content string) []time.Time {
return dates
}
+// maxDate возвращает самую позднюю дату из списка — используется как
+// "дата, до которой отсутствует" для отпуска/больничного.
func maxDate(dates []time.Time) time.Time {
max := dates[0]
for _, d := range dates[1:] {
@@ -411,6 +549,11 @@ func maxDate(dates []time.Time) time.Time {
return max
}
+// absenceCoversDate решает, покрывает ли разобранный набор дат указанный
+// день. Если дат ровно 2 и в исходном тексте между ними есть дефис —
+// считаем их непрерывным диапазоном "с ... по ..." (как в
+// "11.07.2026-24.07.2026"). Иначе — это список отдельных дней (как в
+// "24,07.2026 и 27.07.2026", или просто один день).
func absenceCoversDate(dates []time.Time, content string, y int, m time.Month, d int) bool {
target := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)