diff --git a/core/db/db.go b/core/db/db.go
index 8c7dbc5..d728e3c 100644
--- a/core/db/db.go
+++ b/core/db/db.go
@@ -42,6 +42,7 @@ type ModuleDB struct {
AdminActionLogs *dbcore.AdminActionLogDB
SMSLog *dbcore.SmsLogDB
MonthlyOrders *dbcore.MonthlyOrderDB
+ TaskDelegation *dbcore.TaskDelegationDB
}
func NewModuleDB(
@@ -100,6 +101,7 @@ func initDBModules(modules *ModuleDB, redisClient *redismodule.ModuleRedis) *Mod
modules.AdminActionLogs = dbcore.NewAdminActionLogDB(modules.Pool)
modules.SMSLog = dbcore.NewSmsLogDB(modules.Pool)
modules.MonthlyOrders = dbcore.NewMonthlyOrderDB(modules.Pool)
+ modules.TaskDelegation = dbcore.NewTaskDelegationDB(modules.Pool)
return modules
}
diff --git a/core/db/db_migration/tables.go b/core/db/db_migration/tables.go
index efdc322..cfff54f 100644
--- a/core/db/db_migration/tables.go
+++ b/core/db/db_migration/tables.go
@@ -48,6 +48,7 @@ func (m *MigrationFunctions) migrateTables() error {
tablesmigration.SmsLogsTableMigrate,
tablesmigration.MonthlyOrdersTablesMigrate,
+ tablesmigration.TaskDelegationsTableMigrate,
}
for _, migrate := range migrations {
diff --git a/core/db/db_migration/tables/task_delegation.go b/core/db/db_migration/tables/task_delegation.go
new file mode 100644
index 0000000..152cbe7
--- /dev/null
+++ b/core/db/db_migration/tables/task_delegation.go
@@ -0,0 +1,63 @@
+package tablesmigration
+
+import (
+ "gorm.io/gorm"
+ "time"
+)
+
+// Вспомогательная структура для автомиграции, чтобы не тянуть зависимости
+type LocalTaskDelegation struct {
+ ID *uint64 `gorm:"column:id;primaryKey;autoIncrement"`
+ DelegatorID *uint64 `gorm:"column:delegator_id;not null"`
+ DelegateID *uint64 `gorm:"column:delegate_id;not null"`
+ ValidUntil *time.Time `gorm:"column:valid_until;not null"`
+ IsActive *bool `gorm:"column:is_active;not null;default:true"`
+ NotifiedDay *bool `gorm:"column:notified_day;not null;default:false"`
+ Notified2h *bool `gorm:"column:notified_2h;not null;default:false"`
+ CreatedAt *time.Time `gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
+ UpdatedAt *time.Time `gorm:"column:updated_at;default:CURRENT_TIMESTAMP"`
+}
+
+func (LocalTaskDelegation) TableName() string {
+ return "task_delegations"
+}
+
+func TaskDelegationsTableMigrate(db *gorm.DB) error {
+ hasTable := db.Migrator().HasTable(&LocalTaskDelegation{})
+
+ if err := db.AutoMigrate(&LocalTaskDelegation{}); err != nil {
+ return err
+ }
+
+ if !hasTable {
+ time.Sleep(5 * time.Second)
+
+ // Внешние ключи для связи с таблицей пользователей
+ db.Exec(`ALTER TABLE task_delegations ADD CONSTRAINT fk_task_delegator FOREIGN KEY (delegator_id) REFERENCES users(id) ON DELETE CASCADE ON UPDATE CASCADE`)
+ db.Exec(`ALTER TABLE task_delegations ADD CONSTRAINT fk_task_delegate FOREIGN KEY (delegate_id) REFERENCES users(id) ON DELETE CASCADE ON UPDATE CASCADE`)
+
+ execComments(db, `
+ COMMENT ON TABLE "task_delegations" IS 'Делегирование прав на задачи';
+ COMMENT ON COLUMN "task_delegations".id IS 'Внутренний ID записи делегирования';
+ COMMENT ON COLUMN "task_delegations".delegator_id IS 'ID пользователя, который передает свои задачи (делегатор)';
+ COMMENT ON COLUMN "task_delegations".delegate_id IS 'ID пользователя, которому передаются задачи (делегат)';
+ COMMENT ON COLUMN "task_delegations".valid_until IS 'Дата и время окончания делегирования';
+ COMMENT ON COLUMN "task_delegations".is_active IS 'Активно ли данное делегирование';
+ COMMENT ON COLUMN "task_delegations".notified_day IS 'Отправлено ли уведомление за день до окончания';
+ COMMENT ON COLUMN "task_delegations".notified_2h IS 'Отправлено ли уведомление за 2 часа до окончания';
+ COMMENT ON COLUMN "task_delegations".created_at IS 'Дата создания записи';
+ COMMENT ON COLUMN "task_delegations".updated_at IS 'Дата последнего обновления записи';
+ `)
+ }
+
+ // 🚀 Индексы для быстрого поиска активных делегирований по делегатору
+ db.Exec(`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_delegations_delegator_active ON task_delegations (delegator_id, is_active)`)
+
+ // Индекс для поиска активных делегирований по делегату (чтобы делегат мог видеть переданные ему права)
+ db.Exec(`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_delegations_delegate_active ON task_delegations (delegate_id, is_active)`)
+
+ // Индекс для крона/воркеров, которые будут проверять истекшие сроки и рассылать уведомления
+ db.Exec(`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_task_delegations_valid_until_active ON task_delegations (valid_until, is_active)`)
+
+ return nil
+}
diff --git a/core/db/methods/task_delegation.go b/core/db/methods/task_delegation.go
new file mode 100644
index 0000000..dc6c6c8
--- /dev/null
+++ b/core/db/methods/task_delegation.go
@@ -0,0 +1,186 @@
+package dbcore
+
+import (
+ dbcoretablenames "bitrix_balancer_api/core/db/table_names"
+ "bitrix_balancer_api/core/typescore"
+ dbutils "bitrix_balancer_api/core/utilscore/db"
+ "context"
+ "errors"
+ "github.com/Masterminds/squirrel"
+ "github.com/jackc/pgx/v5"
+ "github.com/jackc/pgx/v5/pgxpool"
+ "github.com/sirupsen/logrus"
+)
+
+type TaskDelegationDB struct {
+ pool *pgxpool.Pool
+}
+
+func NewTaskDelegationDB(pool *pgxpool.Pool) *TaskDelegationDB {
+ return &TaskDelegationDB{
+ pool: pool,
+ }
+}
+
+type TaskDelegationDBI interface {
+ GetTaskDelegationsListDB(ctx context.Context, opts ...typescore.ListDbOptions) ([]*typescore.TaskDelegation, uint64, error)
+ CreateTaskDelegationDB(ctx context.Context, tx pgx.Tx, TaskDelegationObj *typescore.TaskDelegation, returnObj ...bool) (*typescore.TaskDelegation, pgx.Tx, error)
+ UpdateTaskDelegationDB(ctx context.Context, tx pgx.Tx, paramsUpdate *typescore.TaskDelegation, returnObj ...bool) (*typescore.TaskDelegation, pgx.Tx, error)
+ DeleteTaskDelegationDB(ctx context.Context, params *typescore.TaskDelegation) error
+ GetTaskDelegationByIDDB(ctx context.Context, id uint64) (*typescore.TaskDelegation, error)
+}
+
+func (u *TaskDelegationDB) GetTaskDelegationsListDB(ctx context.Context, opts ...typescore.ListDbOptions) ([]*typescore.TaskDelegation, uint64, error) {
+ fields := dbutils.GetStructFieldsDB(&typescore.TaskDelegation{}, dbcoretablenames.TableNameTaskDelegations.ToString())
+ selectFields := append(fields, "COUNT(*) OVER() AS total_count")
+
+ options, filter, err := dbutils.GetOptionsDB[typescore.TaskDelegation](opts...)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ query := dbutils.BuildSelectQuery(dbcoretablenames.TableNameTaskDelegations.ToString(), selectFields)
+ query = dbutils.SetterLimitAndOffsetQuery(query, options.Offset, options.Limit)
+ query = dbutils.ApplyFilters(query, filter, options.LikeFields, dbcoretablenames.TableNameTaskDelegations.ToString())
+ query = query.OrderBy("created_at DESC")
+
+ sql, args, err := query.ToSql()
+ if err != nil {
+ return nil, 0, err
+ }
+
+ rows, err := u.pool.Query(ctx, sql, args...)
+ if err != nil {
+ return nil, 0, err
+ }
+ defer rows.Close()
+
+ var taskDelegations []*typescore.TaskDelegation
+ var totalCount uint64
+ for rows.Next() {
+ taskDelegation := &typescore.TaskDelegation{}
+ if err := dbutils.ScanRowsToStructRows(rows, taskDelegation, &totalCount); err != nil {
+ logrus.Warn("GetTaskDelegationsListDB:ScanRowsToStructRows", err)
+ continue
+ }
+ taskDelegations = append(taskDelegations, taskDelegation)
+ }
+
+ return taskDelegations, totalCount, nil
+}
+
+func (u *TaskDelegationDB) CreateTaskDelegationDB(ctx context.Context, tx pgx.Tx, taskDelegationObj *typescore.TaskDelegation, returnObj ...bool) (*typescore.TaskDelegation, pgx.Tx, error) {
+ if taskDelegationObj == nil {
+ return nil, nil, errors.New("TaskDelegation obj is nil")
+ }
+
+ var insertedID uint64
+
+ err := dbutils.ExecuteTx(ctx, u.pool, tx, func(tx pgx.Tx) error {
+ query := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar).
+ Insert(dbcoretablenames.TableNameTaskDelegations.ToString())
+
+ sqlV, args, err := dbutils.GenerateInsertRequest(query, taskDelegationObj)
+ if err != nil {
+ return err
+ }
+
+ *sqlV = *sqlV + " RETURNING id"
+
+ return tx.QueryRow(ctx, *sqlV, args...).Scan(&insertedID)
+ })
+
+ if err != nil {
+ return nil, tx, err
+ }
+
+ returnObjBool := len(returnObj) > 0 && returnObj[0]
+ if returnObjBool && insertedID > 0 {
+ created, err := u.GetTaskDelegationByIDDB(ctx, insertedID)
+ return created, tx, err
+ }
+
+ return nil, tx, nil
+}
+
+func (u *TaskDelegationDB) UpdateTaskDelegationDB(ctx context.Context, tx pgx.Tx, paramsUpdate *typescore.TaskDelegation, returnObj ...bool) (*typescore.TaskDelegation, pgx.Tx, error) {
+ if paramsUpdate.ID == nil {
+ return nil, nil, errors.New("TaskDelegation obj is nil")
+ }
+
+ err := dbutils.ExecuteTx(ctx, u.pool, tx, func(tx pgx.Tx) error {
+ query := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar).Update(dbcoretablenames.TableNameTaskDelegations.ToString())
+ query = dbutils.AddNonNullFieldsToQueryUpdate(query, *paramsUpdate)
+ query = query.Where(squirrel.Eq{"id": paramsUpdate.ID})
+
+ sql, args, err := query.ToSql()
+ if err != nil {
+ return err
+ }
+
+ _, err = tx.Exec(ctx, sql, args...)
+ if err != nil {
+ return err
+ }
+
+ return nil
+ })
+
+ if err != nil {
+ return nil, tx, err
+ }
+
+ returnObjBool := false
+ if len(returnObj) > 0 {
+ returnObjBool = returnObj[0]
+ }
+
+ if returnObjBool {
+ options := typescore.ListDbOptions{Filtering: &typescore.TaskDelegation{ID: paramsUpdate.ID}}
+ getInfoUp, _, err := u.GetTaskDelegationsListDB(ctx, options)
+ if err != nil {
+ return nil, nil, err
+ }
+ if len(getInfoUp) > 0 {
+ return getInfoUp[0], tx, nil
+ }
+ }
+
+ return nil, tx, nil
+}
+
+func (u *TaskDelegationDB) DeleteTaskDelegationDB(ctx context.Context, params *typescore.TaskDelegation) error {
+ if params != nil && params.ID != nil {
+ query, args, err := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar).
+ Delete(dbcoretablenames.TableNameTaskDelegations.ToString()).
+ Where(squirrel.Eq{"id": *params.ID}).
+ ToSql()
+
+ if err != nil {
+ return err
+ }
+
+ rows, err := u.pool.Query(ctx, query, args...)
+ if err != nil {
+ return err
+ }
+ defer rows.Close()
+
+ return nil
+ } else {
+ return errors.New("TaskDelegation obj is nil")
+ }
+}
+
+func (u *TaskDelegationDB) GetTaskDelegationByIDDB(ctx context.Context, id uint64) (*typescore.TaskDelegation, error) {
+ taskDelegations, _, err := u.GetTaskDelegationsListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.TaskDelegation{ID: &id},
+ })
+ if err != nil {
+ return nil, err
+ }
+ if len(taskDelegations) == 0 {
+ return nil, nil
+ }
+ return taskDelegations[0], nil
+}
diff --git a/core/db/table_names/table_names.go b/core/db/table_names/table_names.go
index d380e59..0e09d75 100644
--- a/core/db/table_names/table_names.go
+++ b/core/db/table_names/table_names.go
@@ -35,6 +35,7 @@ const (
TableNameMonthlyOrderClients TableName = "monthly_order_clients"
TableNameMonthlyOrderItems TableName = "monthly_order_items"
TableNameMonthlyOrderFiles TableName = "monthly_order_files"
+ TableNameTaskDelegations TableName = "task_delegations"
)
func (t TableName) ToString() string {
diff --git a/core/typescore/task_delegations.go b/core/typescore/task_delegations.go
new file mode 100644
index 0000000..b8efe88
--- /dev/null
+++ b/core/typescore/task_delegations.go
@@ -0,0 +1,18 @@
+package typescore
+
+import "time"
+
+type TaskDelegation struct {
+ ID *uint64 `gorm:"column:id;index;type:bigint;autoIncrement;not null;unique" json:"id" db:"id"`
+ DelegatorID *uint64 `gorm:"type:bigint;not null;index;column:delegator_id" json:"delegator_id" db:"delegator_id"`
+ DelegateID *uint64 `gorm:"type:bigint;not null;index;column:delegate_id" json:"delegate_id" db:"delegate_id"`
+ ValidUntil *time.Time `gorm:"type:timestamp;not null;column:valid_until" json:"valid_until" db:"valid_until"`
+ 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"`
+ 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"`
+
+ Delegator *User `gorm:"-" json:"delegator,omitempty"`
+ Delegate *User `gorm:"-" json:"delegate,omitempty"`
+}
diff --git a/service/telegram_service/common/update/callback.go b/service/telegram_service/common/update/callback.go
index 1fc4e6a..e4cf311 100644
--- a/service/telegram_service/common/update/callback.go
+++ b/service/telegram_service/common/update/callback.go
@@ -630,6 +630,51 @@ func (s *UpdateHandler) handleCallback(bot *tgbotapi.BotAPI, cq *tgbotapi.Callba
case strings.HasPrefix(data, "attach_cancel:"):
s.approvalHandler.HandleAttachCancel(bot, cq)
+ // ── ФЛОУ ДЕЛЕГИРОВАНИЯ ЗАДАЧ ──────────────────────────────────────────
+ case data == "deleg_main_menu":
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(cq.Message.Chat.ID, cq.Message.MessageID)) //nolint:errcheck
+ s.approvalHandler.HandleDelegationMainMenu(bot, cq.Message.Chat.ID, cq.From.ID)
+
+ case data == "deleg_task_create":
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(cq.Message.Chat.ID, cq.Message.MessageID)) //nolint:errcheck
+ s.approvalHandler.HandleTaskDelegationSelectUserPage(bot, cq, 0)
+
+ case strings.HasPrefix(data, "deleg_task_user_page:"):
+ page := 0
+ fmt.Sscanf(strings.TrimPrefix(data, "deleg_task_user_page:"), "%d", &page)
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(cq.Message.Chat.ID, cq.Message.MessageID)) //nolint:errcheck
+ s.approvalHandler.HandleTaskDelegationSelectUserPage(bot, cq, page)
+
+ case strings.HasPrefix(data, "deleg_task_user:"):
+ delegateID := parseID(data, "deleg_task_user:")
+ s.approvalHandler.HandleTaskDelegationUserCallback(bot, cq, delegateID)
+
+ case data == "deleg_task_list":
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(cq.Message.Chat.ID, cq.Message.MessageID)) //nolint:errcheck
+ s.approvalHandler.HandleTaskDelegatedRightsList(bot, cq.Message.Chat.ID, cq.From.ID)
+
+ case strings.HasPrefix(data, "deleg_task_list_page:"):
+ page := 0
+ fmt.Sscanf(strings.TrimPrefix(data, "deleg_task_list_page:"), "%d", &page)
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ s.approvalHandler.HandleTaskDelegatedRightsListPage(bot, cq.Message.Chat.ID, cq.From.ID, page, cq.Message.MessageID)
+
+ case strings.HasPrefix(data, "deleg_task_detail:"):
+ delegationID := parseID(data, "deleg_task_detail:")
+ s.approvalHandler.HandleTaskDelegatedRightDetail(bot, cq, delegationID)
+
+ case strings.HasPrefix(data, "deleg_task_revoke:"):
+ delegationID := parseID(data, "deleg_task_revoke:")
+ s.approvalHandler.HandleTaskDelegationRevoke(bot, cq, delegationID)
+
+ case strings.HasPrefix(data, "deleg_task_extend:"):
+ delegationID := parseID(data, "deleg_task_extend:")
+ s.approvalHandler.HandleTaskDelegationExtendPrompt(bot, cq, delegationID)
+
// ── ПРОЧЕЕ ──────────────────────────────────────────────────
case data == "restart_bot":
bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
diff --git a/service/telegram_service/common/update/update.go b/service/telegram_service/common/update/update.go
index 0abb484..7a4a1a1 100644
--- a/service/telegram_service/common/update/update.go
+++ b/service/telegram_service/common/update/update.go
@@ -253,6 +253,14 @@ func (s *UpdateHandler) handleMessage(bot *tgbotapi.BotAPI, msg *tgbotapi.Messag
if s.approvalHandler.HandleDelegationExtendInput(bot, msg) {
return
}
+ // Перехват ввода даты для создания делегирования задач
+ if s.approvalHandler.HandleTaskDelegationDateInput(bot, msg) {
+ return
+ }
+ // Перехват ввода даты для продления делегирования задач
+ if s.approvalHandler.HandleTaskDelegationExtendInput(bot, msg) {
+ return
+ }
s.withDepartmentCheck(bot, msg, func() {
s.approvalHandler.HandleTextInput(bot, msg)
diff --git a/service/telegram_service/handlers/approval/handler_delegation.go b/service/telegram_service/handlers/approval/handler_delegation.go
index c5c2232..cb31431 100644
--- a/service/telegram_service/handlers/approval/handler_delegation.go
+++ b/service/telegram_service/handlers/approval/handler_delegation.go
@@ -278,8 +278,6 @@ func (h *Handler) HandleDelegationDateInput(bot *tgbotapi.BotAPI, msg *tgbotapi.
return true
}
- // ИСПРАВЛЕНИЕ 1: Проверяем, является ли текущий пользователь делегатом
- // Если да - создаём делегирование от имени оригинального согласующего
actualDelegatorID := user.ID
if delegationState.TopicID > 0 {
diff --git a/service/telegram_service/handlers/approval/handler_delegation_tasks.go b/service/telegram_service/handlers/approval/handler_delegation_tasks.go
new file mode 100644
index 0000000..28e53f0
--- /dev/null
+++ b/service/telegram_service/handlers/approval/handler_delegation_tasks.go
@@ -0,0 +1,414 @@
+package approval
+
+import (
+ "bitrix_balancer_api/core/lib/external/tgkit"
+ "bitrix_balancer_api/core/typescore"
+ "bitrix_balancer_api/core/utilscore"
+ "bitrix_balancer_api/telegram_service/keyboard"
+ "bitrix_balancer_api/telegram_service/state"
+ "context"
+ "fmt"
+ "strings"
+ "time"
+
+ tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+ "github.com/sirupsen/logrus"
+)
+
+// HandleTaskDelegationSelectUserPage показывает список сотрудников для делегирования задач
+func (h *Handler) HandleTaskDelegationSelectUserPage(bot *tgbotapi.BotAPI, cq *tgbotapi.CallbackQuery, page int) {
+ ctx := context.Background()
+ chatID := cq.Message.Chat.ID
+ telegramID := cq.From.ID
+
+ user, err := h.ipc.Database.User.GetUserByTelegramIDDB(ctx, telegramID)
+ if err != nil || user == nil || user.ID == nil {
+ return
+ }
+
+ users, _, err := h.ipc.Database.User.GetUsersListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.User{
+ IsBlocked: utilscore.PointerToBool(false),
+ },
+ })
+ if err != nil {
+ logrus.Errorf("HandleTaskDelegationSelectUserPage: GetUsersListDB err=%v", err)
+ return
+ }
+
+ var availableUsers []*typescore.User
+ for _, u := range users {
+ if u.ID != nil && *u.ID != *user.ID {
+ availableUsers = append(availableUsers, u)
+ }
+ }
+
+ if len(availableUsers) == 0 {
+ sendText(bot, chatID, "Нет доступных пользователей для делегирования.")
+ return
+ }
+
+ msg := tgbotapi.NewMessage(chatID, "📋 Делегирование задач\n\nВыберите пользователя, которому хотите передать свои задачи:")
+ msg.ParseMode = "HTML"
+ msg.ReplyMarkup = keyboard.BuildTaskDelegationUserMenu(availableUsers, page)
+ bot.Send(msg) //nolint:errcheck
+}
+
+// HandleTaskDelegationUserCallback сохраняет выбранного делегата и запрашивает дату
+func (h *Handler) HandleTaskDelegationUserCallback(bot *tgbotapi.BotAPI, cq *tgbotapi.CallbackQuery, delegateID uint64) {
+ ctx := context.Background()
+ chatID := cq.Message.Chat.ID
+ telegramID := cq.From.ID
+
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(chatID, cq.Message.MessageID)) //nolint:errcheck
+
+ user, _ := h.ipc.Database.User.GetUserByTelegramIDDB(ctx, telegramID)
+ if user == nil || user.ID == nil {
+ return
+ }
+
+ // Проверяем, нет ли уже активного делегирования всех задач (можно передать только одному человеку)
+ existingDelegations, _, err := h.ipc.Database.TaskDelegation.GetTaskDelegationsListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.TaskDelegation{
+ DelegatorID: user.ID,
+ IsActive: utilscore.PointerToBool(true),
+ },
+ })
+ if err == nil && len(existingDelegations) > 0 {
+ sendText(bot, chatID, "⚠️ У вас уже есть активное делегирование задач.\nСначала отзовите его в меню «Мои делегирования (Задачи)».")
+ return
+ }
+
+ // Сохраняем стейт (переиспользуем DelegationFlowState, но с особым Stage)
+ h.States.SetDelegation(ctx, telegramID, &state.DelegationFlowState{
+ DelegateID: delegateID,
+ Stage: "task_input_date",
+ }) //nolint:errcheck
+
+ delegate, _ := h.ipc.Database.User.GetUserByIDDB(ctx, delegateID)
+ delegateName := "—"
+ if delegate != nil && delegate.FullName != nil {
+ delegateName = *delegate.FullName
+ }
+
+ msg := tgbotapi.NewMessage(chatID, fmt.Sprintf(
+ "👤 Делегат для задач: %s\n\n"+
+ "Введите дату и время окончания делегирования в формате:\n"+
+ "ДД.ММ.ГГГГ ЧЧ:ММ или ДД.ММ.ГГГГ\n\n"+
+ "Например: 31.12.2024 18:00 или 31.12.2024",
+ delegateName,
+ ))
+ msg.ParseMode = "HTML"
+ msg.ReplyMarkup = tgkit.NewInlineKeyboard().
+ Row(tgkit.BtnStyled(tgkit.ButtonStyleBack, "Отмена", "deleg_task_create")).
+ Build()
+ bot.Send(msg) //nolint:errcheck
+}
+
+// HandleTaskDelegationDateInput перехватывает ввод текста с датой
+func (h *Handler) HandleTaskDelegationDateInput(bot *tgbotapi.BotAPI, msg *tgbotapi.Message) bool {
+ ctx := context.Background()
+ telegramID := msg.From.ID
+ chatID := msg.Chat.ID
+
+ delegationState, err := h.States.GetDelegation(ctx, telegramID)
+ if err != nil || delegationState == nil || delegationState.Stage != "task_input_date" {
+ return false // Не наше состояние, отдаем дальше по цепочке
+ }
+
+ dateStr := strings.TrimSpace(msg.Text)
+ var validUntil time.Time
+
+ if t, err := time.Parse("02.01.2006 15:04", dateStr); err == nil {
+ validUntil = t
+ } else if t, err := time.Parse("02.01.2006", dateStr); err == nil {
+ validUntil = time.Date(t.Year(), t.Month(), t.Day(), 23, 59, 59, 0, t.Location())
+ } else {
+ sendText(bot, chatID, "⚠️ Неверный формат даты. Используйте ДД.ММ.ГГГГ ЧЧ:ММ или ДД.ММ.ГГГГ")
+ return true // Состояние наше, но ошибка ввода
+ }
+
+ if validUntil.Before(time.Now()) {
+ sendText(bot, chatID, "⚠️ Дата окончания не может быть в прошлом.")
+ return true
+ }
+
+ user, err := h.ipc.Database.User.GetUserByTelegramIDDB(ctx, telegramID)
+ if err != nil || user == nil || user.ID == nil {
+ return true
+ }
+
+ isActive := true
+ notifiedFalse := false
+ delegation := &typescore.TaskDelegation{
+ DelegatorID: user.ID,
+ DelegateID: &delegationState.DelegateID,
+ ValidUntil: &validUntil,
+ IsActive: &isActive,
+ NotifiedDay: ¬ifiedFalse,
+ Notified2h: ¬ifiedFalse,
+ }
+
+ _, _, err = h.ipc.Database.TaskDelegation.CreateTaskDelegationDB(ctx, nil, delegation)
+ if err != nil {
+ logrus.Errorf("HandleTaskDelegationDateInput: CreateTaskDelegationDB err=%v", err)
+ sendText(bot, chatID, "Ошибка при создании делегирования задач.")
+ return true
+ }
+
+ h.States.ClearDelegation(ctx, telegramID) // Очищаем состояние
+
+ delegate, _ := h.ipc.Database.User.GetUserByIDDB(ctx, delegationState.DelegateID)
+ delegateName := "—"
+ if delegate != nil && delegate.FullName != nil {
+ delegateName = *delegate.FullName
+ }
+
+ sendText(bot, chatID, fmt.Sprintf(
+ "✅ Задачи делегированы\n\n"+
+ "👤 Кому: %s\n"+
+ "📅 Действует до: %s\n\n"+
+ "Теперь все новые задачи будут приходить этому сотруднику.",
+ delegateName, validUntil.Format("02.01.2006 15:04"),
+ ))
+
+ // Уведомляем делегата
+ if delegate != nil && delegate.TelegramID != nil {
+ delegatorName := "—"
+ if user.FullName != nil {
+ delegatorName = *user.FullName
+ }
+ notifyMsg := tgbotapi.NewMessage(*delegate.TelegramID, fmt.Sprintf(
+ "🔄 Вам делегировано исполнение задач\n\n"+
+ "👤 От: %s\n"+
+ "📅 До: %s\n\n"+
+ "В этот период все задачи этого пользователя будут поступать вам.",
+ delegatorName, validUntil.Format("02.01.2006 15:04"),
+ ))
+ notifyMsg.ParseMode = "HTML"
+ bot.Send(notifyMsg) //nolint:errcheck
+ }
+
+ return true
+}
+
+func (h *Handler) HandleTaskDelegatedRightsList(bot *tgbotapi.BotAPI, chatID int64, telegramID int64) {
+ h.HandleTaskDelegatedRightsListPage(bot, chatID, telegramID, 0, 0)
+}
+
+func (h *Handler) HandleTaskDelegatedRightsListPage(bot *tgbotapi.BotAPI, chatID int64, telegramID int64, page int, prevMessageID int) {
+ ctx := context.Background()
+
+ user, err := h.ipc.Database.User.GetUserByTelegramIDDB(ctx, telegramID)
+ if err != nil || user == nil || user.ID == nil {
+ return
+ }
+
+ isActive := true
+ delegations, _, err := h.ipc.Database.TaskDelegation.GetTaskDelegationsListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.TaskDelegation{
+ DelegatorID: user.ID,
+ IsActive: &isActive,
+ },
+ })
+ if err != nil {
+ logrus.Errorf("HandleTaskDelegatedRightsList: GetTaskDelegationsListDB err=%v", err)
+ sendText(bot, chatID, "Ошибка при получении списка делегирований задач.")
+ return
+ }
+
+ if len(delegations) == 0 {
+ sendText(bot, chatID, "У вас нет активных делегирований задач.")
+ return
+ }
+
+ if prevMessageID != 0 {
+ bot.Request(tgbotapi.NewDeleteMessage(chatID, prevMessageID)) //nolint:errcheck
+ }
+
+ msg := tgbotapi.NewMessage(chatID, fmt.Sprintf("📋 Делегированные задачи (%d)\n\nВыберите запись:", len(delegations)))
+ msg.ParseMode = "HTML"
+ msg.ReplyMarkup = keyboard.BuildTaskDelegatedRightsList(delegations, page, ctx, h.ipc)
+ bot.Send(msg) //nolint:errcheck
+}
+
+func (h *Handler) HandleTaskDelegatedRightDetail(bot *tgbotapi.BotAPI, cq *tgbotapi.CallbackQuery, delegationID uint64) {
+ ctx := context.Background()
+ chatID := cq.Message.Chat.ID
+
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(chatID, cq.Message.MessageID)) //nolint:errcheck
+
+ delegation, err := h.ipc.Database.TaskDelegation.GetTaskDelegationByIDDB(ctx, delegationID)
+ if err != nil || delegation == nil {
+ sendText(bot, chatID, "⚠️ Делегирование не найдено.")
+ return
+ }
+
+ delegateName := "—"
+ if delegation.DelegateID != nil {
+ delegate, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *delegation.DelegateID)
+ if delegate != nil && delegate.FullName != nil {
+ delegateName = *delegate.FullName
+ }
+ }
+
+ validUntil := "—"
+ if delegation.ValidUntil != nil {
+ validUntil = delegation.ValidUntil.Format("02.01.2006 15:04")
+ }
+
+ text := fmt.Sprintf(
+ "📋 Делегирование задач #%d\n\n"+
+ "👤 Делегат: %s\n"+
+ "📅 Действует до: %s",
+ delegationID, delegateName, validUntil,
+ )
+
+ msg := tgbotapi.NewMessage(chatID, text)
+ msg.ParseMode = "HTML"
+ msg.ReplyMarkup = keyboard.BuildTaskDelegationActions(delegationID)
+ bot.Send(msg) //nolint:errcheck
+}
+
+func (h *Handler) HandleTaskDelegationRevoke(bot *tgbotapi.BotAPI, cq *tgbotapi.CallbackQuery, delegationID uint64) {
+ ctx := context.Background()
+ chatID := cq.Message.Chat.ID
+
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(chatID, cq.Message.MessageID)) //nolint:errcheck
+
+ delegation, err := h.ipc.Database.TaskDelegation.GetTaskDelegationByIDDB(ctx, delegationID)
+ if err != nil || delegation == nil {
+ sendText(bot, chatID, "⚠️ Делегирование не найдено.")
+ return
+ }
+
+ now := time.Now()
+ isActive := false
+ delegation.ValidUntil = &now
+ delegation.IsActive = &isActive
+
+ _, _, err = h.ipc.Database.TaskDelegation.UpdateTaskDelegationDB(ctx, nil, delegation)
+ if err != nil {
+ logrus.Errorf("HandleTaskDelegationRevoke: UpdateTaskDelegationDB err=%v", err)
+ sendText(bot, chatID, "Ошибка при отзыве делегирования.")
+ return
+ }
+
+ sendText(bot, chatID, "✅ Делегирование задач досрочно отозвано.\nТеперь новые задачи будут приходить вам.")
+
+ // Уведомляем делегата
+ if delegation.DelegateID != nil {
+ delegate, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *delegation.DelegateID)
+ if delegate != nil && delegate.TelegramID != nil {
+ notifyMsg := tgbotapi.NewMessage(*delegate.TelegramID, "⚠️ Делегирование задач отозвано\n\nВам больше не будут приходить задачи этого пользователя.")
+ notifyMsg.ParseMode = "HTML"
+ bot.Send(notifyMsg) //nolint:errcheck
+ }
+ }
+}
+
+func (h *Handler) HandleTaskDelegationExtendPrompt(bot *tgbotapi.BotAPI, cq *tgbotapi.CallbackQuery, delegationID uint64) {
+ ctx := context.Background()
+ chatID := cq.Message.Chat.ID
+ telegramID := cq.From.ID
+
+ bot.Request(tgbotapi.NewCallback(cq.ID, "")) //nolint:errcheck
+ bot.Request(tgbotapi.NewDeleteMessage(chatID, cq.Message.MessageID)) //nolint:errcheck
+
+ delegation, err := h.ipc.Database.TaskDelegation.GetTaskDelegationByIDDB(ctx, delegationID)
+ if err != nil || delegation == nil {
+ sendText(bot, chatID, "⚠️ Делегирование не найдено.")
+ return
+ }
+
+ // Сохраняем ID делегирования для продления (с другим ключом, чтобы не пересекаться с заявками)
+ extendKey := fmt.Sprintf("task_deleg_extend:%d", telegramID)
+ h.ipc.RedisClient.Set(ctx, extendKey, fmt.Sprintf("%d", delegationID), 10*time.Minute) //nolint:errcheck
+
+ msg := tgbotapi.NewMessage(chatID,
+ "Введите новую дату окончания в формате:\n"+
+ "ДД.ММ.ГГГГ ЧЧ:ММ или ДД.ММ.ГГГГ")
+ msg.ParseMode = "HTML"
+ msg.ReplyMarkup = keyboard.BuildTaskDelegationExtendCancel(delegationID)
+ bot.Send(msg) //nolint:errcheck
+}
+
+func (h *Handler) HandleTaskDelegationExtendInput(bot *tgbotapi.BotAPI, msg *tgbotapi.Message) bool {
+ ctx := context.Background()
+ telegramID := msg.From.ID
+ chatID := msg.Chat.ID
+
+ extendKey := fmt.Sprintf("task_deleg_extend:%d", telegramID)
+ raw, err := h.ipc.RedisClient.Get(ctx, extendKey)
+ if err != nil || raw == "" {
+ return false
+ }
+
+ var delegationID uint64
+ fmt.Sscanf(raw, "%d", &delegationID)
+
+ dateStr := strings.TrimSpace(msg.Text)
+ var validUntil time.Time
+
+ if t, err := time.Parse("02.01.2006 15:04", dateStr); err == nil {
+ validUntil = t
+ } else if t, err := time.Parse("02.01.2006", dateStr); err == nil {
+ validUntil = time.Date(t.Year(), t.Month(), t.Day(), 23, 59, 59, 0, t.Location())
+ } else {
+ sendText(bot, chatID, "⚠️ Неверный формат даты. Используйте ДД.ММ.ГГГГ ЧЧ:ММ или ДД.ММ.ГГГГ")
+ return true
+ }
+
+ if validUntil.Before(time.Now()) {
+ sendText(bot, chatID, "⚠️ Дата окончания не может быть в прошлом.")
+ return true
+ }
+
+ delegation, err := h.ipc.Database.TaskDelegation.GetTaskDelegationByIDDB(ctx, delegationID)
+ if err != nil || delegation == nil {
+ sendText(bot, chatID, "⚠️ Делегирование не найдено.")
+ h.ipc.RedisClient.Del(ctx, extendKey) //nolint:errcheck
+ return true
+ }
+
+ delegation.ValidUntil = &validUntil
+ notifiedDay := false
+ notified2h := false
+ delegation.NotifiedDay = ¬ifiedDay
+ delegation.Notified2h = ¬ified2h
+
+ _, _, err = h.ipc.Database.TaskDelegation.UpdateTaskDelegationDB(ctx, nil, delegation)
+ if err != nil {
+ logrus.Errorf("HandleTaskDelegationExtendInput: UpdateTaskDelegationDB err=%v", err)
+ sendText(bot, chatID, "Ошибка при продлении делегирования задач.")
+ h.ipc.RedisClient.Del(ctx, extendKey) //nolint:errcheck
+ return true
+ }
+
+ h.ipc.RedisClient.Del(ctx, extendKey) //nolint:errcheck
+
+ sendText(bot, chatID, fmt.Sprintf(
+ "✅ Срок делегирования задач изменён.\n\n"+
+ "📅 Новый срок: %s",
+ validUntil.Format("02.01.2006 15:04"),
+ ))
+
+ // Уведомляем делегата
+ if delegation.DelegateID != nil {
+ delegate, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *delegation.DelegateID)
+ if delegate != nil && delegate.TelegramID != nil {
+ notifyMsg := tgbotapi.NewMessage(*delegate.TelegramID, fmt.Sprintf(
+ "🔄 Срок делегирования задач изменён.\n\n"+
+ "📅 Новый срок: %s",
+ validUntil.Format("02.01.2006 15:04"),
+ ))
+ notifyMsg.ParseMode = "HTML"
+ bot.Send(notifyMsg) //nolint:errcheck
+ }
+ }
+
+ return true
+}
diff --git a/service/telegram_service/handlers/approval/handler_executor.go b/service/telegram_service/handlers/approval/handler_executor.go
index b82cc2d..c0f4e75 100644
--- a/service/telegram_service/handlers/approval/handler_executor.go
+++ b/service/telegram_service/handlers/approval/handler_executor.go
@@ -256,6 +256,7 @@ func (h *Handler) HandleCompleteTask(bot *tgbotapi.BotAPI, cq *tgbotapi.Callback
}
}
+// activateNextTask активирует следующую задачу в очереди после завершения текущей
// activateNextTask активирует следующую задачу в очереди после завершения текущей
func (h *Handler) activateNextTask(bot *tgbotapi.BotAPI, ctx context.Context, approval *typescore.Approval, completedTask *typescore.ApprovalTask) {
if approval == nil || approval.ID == nil || completedTask.StepOrder == nil {
@@ -283,21 +284,38 @@ func (h *Handler) activateNextTask(bot *tgbotapi.BotAPI, ctx context.Context, ap
return
}
+ originalExecutor, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *nextTask.ExecutorID)
+ var actualExecutor *typescore.User
+
+ if originalExecutor != nil {
+ actual, isDelegated, orig := h.getActualTaskExecutor(ctx, originalExecutor)
+ actualExecutor = actual
+
+ // Если за время ожидания задачи человек ушел в отпуск/делегировал права,
+ // перезаписываем ExecutorID и текст задачи
+ if isDelegated && orig != nil && orig.FullName != nil {
+ nextTask.ExecutorID = actual.ID
+ newText := fmt.Sprintf("[Делегировано от: %s]\n%s", *orig.FullName, *nextTask.TaskText)
+ nextTask.TaskText = &newText
+ }
+ }
+
pendingStatus := "pending"
nextTask.Status = &pendingStatus
+
_, _, err = h.ipc.Database.ApprovalTasks.UpdateApprovalTaskDB(ctx, nil, nextTask)
if err != nil {
logrus.Errorf("activateNextTask: UpdateApprovalTaskDB err=%v", err)
return
}
- executor, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *nextTask.ExecutorID)
- if executor != nil && executor.TelegramID != nil {
+ // Уведомляем АКТУАЛЬНОГО исполнителя
+ if actualExecutor != nil && actualExecutor.TelegramID != nil {
initiator, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *approval.InitiatorID)
if initiator == nil {
return
}
- h.notifyExecutor(bot, ctx, executor, initiator, approval, nextTask)
+ h.notifyExecutor(bot, ctx, actualExecutor, initiator, approval, nextTask)
}
}
diff --git a/service/telegram_service/handlers/approval/selection_approver.go b/service/telegram_service/handlers/approval/selection_approver.go
index 850f79e..b46db58 100644
--- a/service/telegram_service/handlers/approval/selection_approver.go
+++ b/service/telegram_service/handlers/approval/selection_approver.go
@@ -2,11 +2,13 @@ package approval
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"
"strings"
+ "time"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
"github.com/sirupsen/logrus"
@@ -403,6 +405,33 @@ func (h *Handler) sendConfirmationCard(bot *tgbotapi.BotAPI, ctx context.Context
bot.Send(msgChat) //nolint:errcheck
}
+// getActualTaskExecutor проверяет, не делегировал ли оригинальный исполнитель свои задачи.
+// Возвращает: (Актуальный исполнитель, Было ли делегирование, Оригинальный исполнитель)
+func (h *Handler) getActualTaskExecutor(ctx context.Context, originalExecutor *typescore.User) (*typescore.User, bool, *typescore.User) {
+ if originalExecutor == nil || originalExecutor.ID == nil {
+ return originalExecutor, false, nil
+ }
+
+ delegations, _, err := h.ipc.Database.TaskDelegation.GetTaskDelegationsListDB(ctx, typescore.ListDbOptions{
+ Filtering: &typescore.TaskDelegation{
+ DelegatorID: originalExecutor.ID,
+ IsActive: utilscore.PointerToBool(true),
+ },
+ })
+
+ if err == nil && len(delegations) > 0 {
+ deleg := delegations[0]
+ if deleg.ValidUntil != nil && deleg.ValidUntil.After(time.Now()) && deleg.DelegateID != nil {
+ delegateUser, err := h.ipc.Database.User.GetUserByIDDB(ctx, *deleg.DelegateID)
+ if err == nil && delegateUser != nil {
+ return delegateUser, true, originalExecutor
+ }
+ }
+ }
+
+ return originalExecutor, false, nil
+}
+
// createTasksForApproval создаёт задачи для исполнителей на основе конфигурации темы
func (h *Handler) createTasksForApproval(
bot *tgbotapi.BotAPI,
@@ -441,6 +470,8 @@ func (h *Handler) createTasksForApproval(
taskCounter := 0
+ // ... (начало метода createTasksForApproval остается без изменений) ...
+
for _, system := range systemsToProcess {
for _, topicExec := range topicExecutors {
if topicExec.UserID == nil {
@@ -455,12 +486,21 @@ func (h *Handler) createTasksForApproval(
continue
}
- executor, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *topicExec.UserID)
- if executor == nil || executor.ID == nil {
+ originalExecutor, _ := h.ipc.Database.User.GetUserByIDDB(ctx, *topicExec.UserID)
+ if originalExecutor == nil || originalExecutor.ID == nil {
continue
}
+ // 🚀 ПРОВЕРКА ДЕЛЕГИРОВАНИЯ
+ actualExecutor, isDelegated, origExec := h.getActualTaskExecutor(ctx, originalExecutor)
+
taskText := *topicExec.TaskText
+
+ // Если задача делегирована, добавляем пометку в текст задачи
+ if isDelegated && origExec != nil && origExec.FullName != nil {
+ taskText = fmt.Sprintf("[Делегировано от: %s]\n%s", *origExec.FullName, taskText)
+ }
+
systemLabel := ""
if system != "all" && system != "" {
switch system {
@@ -483,22 +523,25 @@ func (h *Handler) createTasksForApproval(
requireFile = *topicExec.RequireFile
}
+ // Создаем задачу на АКТУАЛЬНОГО исполнителя
createdTask, _, err := h.ipc.Database.ApprovalTasks.CreateApprovalTaskDB(ctx, nil, &typescore.ApprovalTask{
ApprovalID: approval.ID,
- ExecutorID: executor.ID,
+ ExecutorID: actualExecutor.ID, // <--- Подменённый ID
TaskText: &taskText,
Status: &taskStatus,
StepOrder: &stepOrder,
RequireFile: &requireFile,
TopicExecutorID: topicExec.ID,
}, true)
+
if err != nil {
- logrus.Errorf("createTasksForApproval: CreateApprovalTask system=%s executor=%d err=%v", system, *executor.ID, err)
+ logrus.Errorf("createTasksForApproval: CreateApprovalTask system=%s executor=%d err=%v", system, *actualExecutor.ID, err)
continue
}
- if createdTask != nil && taskStatus == "pending" && executor.TelegramID != nil {
- h.notifyExecutor(bot, ctx, executor, initiator, approval, createdTask)
+ // Уведомляем АКТУАЛЬНОГО исполнителя
+ if createdTask != nil && taskStatus == "pending" && actualExecutor.TelegramID != nil {
+ h.notifyExecutor(bot, ctx, actualExecutor, initiator, approval, createdTask)
}
taskCounter++
diff --git a/service/telegram_service/keyboard/delegation.go b/service/telegram_service/keyboard/delegation.go
index 75e6cd4..918068f 100644
--- a/service/telegram_service/keyboard/delegation.go
+++ b/service/telegram_service/keyboard/delegation.go
@@ -15,8 +15,10 @@ const delegationPerPage = 6
func BuildDelegationMainMenu() interface{} {
return tgkit.NewInlineKeyboard().
- Row(tgkit.BtnStyled(tgkit.ButtonStyleSuccess, "Делегировать права", "deleg_create")).
- Row(tgkit.Btn("📋 Делегированные права", "deleg_list")).
+ Row(tgkit.BtnStyled(tgkit.ButtonStyleSuccess, "Делегировать заявки", "deleg_create")).
+ Row(tgkit.BtnStyled(tgkit.ButtonStyleSuccess, "Делегировать задачи", "deleg_task_create")).
+ Row(tgkit.Btn("📋 Мои делегирования (Заявки)", "deleg_list")).
+ Row(tgkit.Btn("📋 Мои делегирования (Задачи)", "deleg_task_list")).
Build()
}
@@ -170,3 +172,87 @@ func BuildDelegationBackToUsers(categoryID, topicID uint64) tgbotapi.InlineKeybo
Row(tgkit.BtnStyled(tgkit.ButtonStyleBack, "Назад", callback)).
Build()
}
+
+// --- КЛАВИАТУРЫ ДЛЯ ДЕЛЕГИРОВАНИЯ ЗАДАЧ ---
+
+// BuildTaskDelegationUserMenu выводит список пользователей для передачи задач
+func BuildTaskDelegationUserMenu(users []*typescore.User, page int) interface{} {
+ const perPage = 8
+ total := len(users)
+ totalPages := (total + perPage - 1) / perPage
+ if page < 0 {
+ page = 0
+ }
+ if page >= totalPages && totalPages > 0 {
+ page = totalPages - 1
+ }
+ start, end := page*perPage, page*perPage+perPage
+ if end > total {
+ end = total
+ }
+
+ kb := tgkit.NewInlineKeyboard()
+ for _, u := range users[start:end] {
+ if u.ID == nil || u.FullName == nil {
+ continue
+ }
+ kb.Row(tgkit.Btn(*u.FullName, fmt.Sprintf("deleg_task_user:%d", *u.ID)))
+ }
+ if totalPages > 1 {
+ kb.Rows = append(kb.Rows, buildPageRow(page, totalPages, "deleg_task_user_page", "deleg_page_noop"))
+ }
+ // Кнопка возврата в главное меню делегирования
+ kb.Row(tgkit.BtnStyled(tgkit.ButtonStyleBack, "Назад", "deleg_main_menu"))
+ return kb.Build()
+}
+
+// BuildTaskDelegatedRightsList выводит список ваших активных делегирований задач
+func BuildTaskDelegatedRightsList(delegations []*typescore.TaskDelegation, page int, ctx context.Context, ipc *types.InternalProviderControl) interface{} {
+ const perPage = 6
+ total := len(delegations)
+ totalPages := (total + perPage - 1) / perPage
+ if page < 0 {
+ page = 0
+ }
+ if page >= totalPages && totalPages > 0 {
+ page = totalPages - 1
+ }
+ start, end := page*perPage, page*perPage+perPage
+ if end > total {
+ end = total
+ }
+
+ kb := tgkit.NewInlineKeyboard()
+ for _, d := range delegations[start:end] {
+ if d.ID == nil || d.DelegateID == nil {
+ continue
+ }
+ delegateName := "Неизвестно"
+ if u, _ := ipc.Database.User.GetUserByIDDB(ctx, *d.DelegateID); u != nil && u.FullName != nil {
+ delegateName = *u.FullName
+ }
+
+ kb.Row(tgkit.Btn(fmt.Sprintf("Задачи ➡️ %s", delegateName), fmt.Sprintf("deleg_task_detail:%d", *d.ID)))
+ }
+ if totalPages > 1 {
+ kb.Rows = append(kb.Rows, buildPageRow(page, totalPages, "deleg_task_list_page", "deleg_page_noop"))
+ }
+ kb.Row(tgkit.BtnStyled(tgkit.ButtonStyleBack, "В главное меню", "deleg_main_menu"))
+ return kb.Build()
+}
+
+// BuildTaskDelegationActions выводит кнопки управления (Отозвать/Продлить) конкретным делегированием задач
+func BuildTaskDelegationActions(delegationID uint64) interface{} {
+ return tgkit.NewInlineKeyboard().
+ Row(tgkit.Btn("📅 Изменить срок", fmt.Sprintf("deleg_task_extend:%d", delegationID))).
+ Row(tgkit.BtnStyled(tgkit.ButtonStyleDanger, "Отозвать делегирование", fmt.Sprintf("deleg_task_revoke:%d", delegationID))).
+ Row(tgkit.BtnStyled(tgkit.ButtonStyleBack, "К списку", "deleg_task_list")).
+ Build()
+}
+
+// BuildTaskDelegationExtendCancel кнопка отмены при вводе новой даты
+func BuildTaskDelegationExtendCancel(delegationID uint64) interface{} {
+ return tgkit.NewInlineKeyboard().
+ Row(tgkit.BtnStyled(tgkit.ButtonStyleBack, "Отмена", fmt.Sprintf("deleg_task_detail:%d", delegationID))).
+ Build()
+}