package bitrix import ( "bytes" "context" "crypto/hmac" "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "io" "net/http" "net/url" "strconv" "strings" "time" ) type Service struct { bitrixWebhookURL string loadBalancerURL string client *http.Client retries int backoff time.Duration apiKeyPrivate string apiKeyPublic string } type BitrixPayload struct { Url string `json:"url"` Method string `json:"method"` Body interface{} `json:"body"` } func NewService(bitrixWebhookURL string, loadBalancerURL string, apiKeyPrivate string, apiKeyPublic string) *Service { return &Service{ bitrixWebhookURL: bitrixWebhookURL, loadBalancerURL: loadBalancerURL, client: &http.Client{ Timeout: 15 * time.Minute, }, retries: 1, backoff: 1 * time.Second, apiKeyPrivate: apiKeyPrivate, apiKeyPublic: apiKeyPublic, } } type bitrixError struct { Error string `json:"error"` ErrorDescription string `json:"error_description"` } func generateSignature(timestamp string, apiKeyPrivate string, apiKeyPublic string) string { message := fmt.Sprintf("%s:%s", apiKeyPublic, timestamp) h := hmac.New(sha256.New, []byte(apiKeyPrivate)) h.Write([]byte(message)) return hex.EncodeToString(h.Sum(nil)) } func (s *Service) call( ctx context.Context, method string, payload interface{}, result interface{}, ) error { bitrixWebhookURL := fmt.Sprintf("%s%s.json", s.bitrixWebhookURL, method) packagedBitrixPayload := BitrixPayload{ Url: bitrixWebhookURL, Method: "POST", Body: payload, } body, err := json.Marshal(packagedBitrixPayload) if err != nil { return err } var lastErr error req, err := http.NewRequestWithContext( ctx, http.MethodPost, s.loadBalancerURL, bytes.NewBuffer(body), ) if err != nil { return err } timestamp := fmt.Sprintf("%d", time.Now().Unix()) req.Header.Set("Content-Type", "application/json") req.Header.Set("X-Timestamp", timestamp) req.Header.Set("X-Signature", generateSignature(timestamp, s.apiKeyPrivate, s.apiKeyPublic)) resp, err := s.client.Do(req) if err != nil { lastErr = err } else { func() { defer resp.Body.Close() respBody, err := io.ReadAll(resp.Body) if err != nil { lastErr = err return } if resp.StatusCode >= 500 { lastErr = fmt.Errorf("server error: %s", resp.Status) return } respBody = bytes.TrimSpace(respBody) if len(respBody) == 0 { lastErr = nil return } var wrapper struct { Body struct { Result json.RawMessage `json:"result"` Error string `json:"error"` ErrorDescription string `json:"error_description"` } `json:"body"` } if err := json.Unmarshal(respBody, &wrapper); err != nil { lastErr = err return } if wrapper.Body.Error != "" { lastErr = fmt.Errorf("%s: %s", wrapper.Body.Error, wrapper.Body.ErrorDescription) return } if result != nil { raw := bytes.TrimSpace(wrapper.Body.Result) if bytes.Equal(raw, []byte("[]")) { lastErr = nil return } if len(raw) == 0 || bytes.Equal(raw, []byte("null")) { lastErr = nil return } if err := json.Unmarshal(wrapper.Body.Result, result); err != nil { lastErr = err return } } lastErr = nil }() if lastErr == nil { return nil } } return fmt.Errorf("bitrix call failed: %w", lastErr) } func (s *Service) GetTaskUsers( ctx context.Context, taskID int, ) (int, []int, error) { payload := map[string]interface{}{ "taskId": taskID, "select": []string{"CHANGED_BY", "AUDITORS"}, } var resp struct { Task struct { ChangedBy string `json:"changedBy"` Auditors []string `json:"auditors"` } `json:"task"` } err := s.call(ctx, "tasks.task.get", payload, &resp) if err != nil { return 0, nil, err } changedBy, err := strconv.Atoi(resp.Task.ChangedBy) if err != nil { return 0, nil, err } auditors := make([]int, len(resp.Task.Auditors)) for i, idStr := range resp.Task.Auditors { id, err := strconv.Atoi(idStr) if err != nil { return 0, nil, err } auditors[i] = id } return changedBy, auditors, nil } func (s *Service) SetTaskAuditors( ctx context.Context, taskID int, auditors []int, ) error { auditorsStr := make([]string, len(auditors)) for i, id := range auditors { auditorsStr[i] = strconv.Itoa(id) } payload := map[string]interface{}{ "taskId": taskID, "fields": map[string]interface{}{ "AUDITORS": auditorsStr, }, } var resp struct { Result interface{} `json:"result"` } return s.call(ctx, "tasks.task.update", payload, &resp) } func (s *Service) SyncTaskCompletion(ctx context.Context, taskID int) error { type taskInfo struct { Status int `json:"status,string"` IsCopyString string `json:"ufAuto682289870673"` CopyID int `json:"ufAuto889836441236,string"` ParentID int `json:"parentId,string"` TaskControl string `json:"taskControl"` } getPayload := map[string]interface{}{ "taskId": taskID, "select": []string{ "STATUS", "UF_AUTO_889836441236", "UF_AUTO_682289870673", "PARENT_ID", "TASK_CONTROL", }, } var getResp struct { Task taskInfo `json:"task"` } if err := s.call(ctx, "tasks.task.get", getPayload, &getResp); err != nil { return err } current := getResp.Task if current.Status == 5 { err := s.CompleteSubtasks(ctx, taskID) if err != nil { return err } } return nil } func (s *Service) SetTaskControl(ctx context.Context, taskID int, control bool) error { controlStr := "N" if control { controlStr = "Y" } payload := map[string]interface{}{ "taskId": taskID, "fields": map[string]interface{}{ "TASK_CONTROL": controlStr, }, } var resp struct { Result interface{} `json:"result"` } return s.call(ctx, "tasks.task.update", payload, &resp) } type taskInfo struct { ResponsibleID int `json:"responsibleId,string"` ChangedBy int `json:"changedBy,string"` TaskName string `json:"title"` } func (s *Service) GetTaskInfo( ctx context.Context, taskID int, ) (*taskInfo, error) { // --- 1. Получаем задачу --- getTaskPayload := map[string]interface{}{ "taskId": taskID, "select": []string{ "RESPONSIBLE_ID", "CHANGED_BY", "TITLE", }, } var taskResp struct { Task taskInfo `json:"task"` } if err := s.call(ctx, "tasks.task.get", getTaskPayload, &taskResp); err != nil { return nil, err } return &taskResp.Task, nil } func (s *Service) IsSelfRequest( changedBy int, excludedUserID int, ) bool { return changedBy == excludedUserID } func (s *Service) ValidateTaskUserDeps( ctx context.Context, responsibleID int, allowedDepartmentIDs []int, ) (bool, []int, error) { // --- 3. Получаем отделы исполнителя --- getUserPayload := map[string]interface{}{ "filter": map[string]interface{}{ "ID": responsibleID, }, "select": []string{"UF_DEPARTMENT"}, } var users []struct { Departments []int `json:"UF_DEPARTMENT"` } if err := s.call(ctx, "user.get", getUserPayload, &users); err != nil { return false, []int{}, err } if len(users) == 0 { return false, []int{}, nil } userDepartments := users[0].Departments // --- 4. Проверяем пересечение отделов --- deptSet := make(map[int]struct{}, len(allowedDepartmentIDs)) for _, id := range allowedDepartmentIDs { deptSet[id] = struct{}{} } for _, userDept := range userDepartments { if _, ok := deptSet[userDept]; ok { return true, userDepartments, nil } } return false, []int{}, nil } type TaskTag struct { ID int `json:"id"` Title string `json:"title"` } type TaskTags map[string]TaskTag func (t *TaskTags) UnmarshalJSON(data []byte) error { // Если пришёл пустой массив if string(data) == "[]" { *t = make(TaskTags) return nil } // Если пришёл null if string(data) == "null" { *t = make(TaskTags) return nil } // Пробуем распарсить как объект var obj map[string]TaskTag if err := json.Unmarshal(data, &obj); err == nil { *t = obj return nil } return fmt.Errorf("unsupported tags format: %s", string(data)) } type CRMTags []string func (c *CRMTags) UnmarshalJSON(data []byte) error { // null → пустой слайс if string(data) == "null" { *c = []string{} return nil } // Пробуем распарсить как массив строк var arr []string if err := json.Unmarshal(data, &arr); err == nil { *c = arr return nil } // Если приходит одиночная строка (редкий кейс) var s string if err := json.Unmarshal(data, &s); err == nil { *c = []string{s} return nil } return fmt.Errorf("unsupported ufCrmTask format: %s", string(data)) } type TaskDetails struct { ID int `json:"id,string"` ParentID int `json:"parentId,string"` IsCopy *string `json:"ufAuto682289870673"` CopyID *string `json:"ufAuto889836441236"` ResponsibleID int `json:"responsibleId,string"` CreatorID int `json:"createdBy,string"` Title string `json:"title"` Deadline *string `json:"deadline"` CRMElements CRMTags `json:"ufCrmTask"` Description string `json:"description"` RequiresAcceptance string `json:"allowChangeDeadline"` ProjectID int `json:"groupId,string"` Tags TaskTags `json:"tags"` } type taskWrapper struct { Task TaskOrArray `json:"task"` } type TaskOrArray struct { Task *TaskDetails } func (t *TaskOrArray) UnmarshalJSON(data []byte) error { if len(data) == 0 || string(data) == "null" { t.Task = nil return nil } if data[0] == '[' { var arr []TaskDetails if err := json.Unmarshal(data, &arr); err != nil { return err } if len(arr) > 0 { t.Task = &arr[0] } else { t.Task = nil } return nil } // объект var obj TaskDetails if err := json.Unmarshal(data, &obj); err != nil { return err } t.Task = &obj return nil } func (s *Service) GetTaskDetails(ctx context.Context, taskID int) (*TaskDetails, error) { payload := map[string]interface{}{ "taskId": taskID, "select": []string{ "ID", "UF_AUTO_682289870673", "UF_AUTO_889836441236", "RESPONSIBLE_ID", "CREATED_BY", "TITLE", "DEADLINE", "UF_CRM_TASK", "DESCRIPTION", "ALLOW_CHANGE_DEADLINE", "GROUP_ID", "TAGS", "PARENT_ID", }, } var resp taskWrapper if err := s.call(ctx, "tasks.task.get", payload, &resp); err != nil { return nil, err } return resp.Task.Task, nil } func extractTagTitles(tags map[string]TaskTag) []string { if tags == nil { return []string{} } result := make([]string, 0, len(tags)) for _, tag := range tags { result = append(result, tag.Title) } return result } func buildAddCopyCommand(task TaskDetails, auditorIDs []int, CRMElementNames []string) string { const taskDescriptionTemplate = `Эта задача является дублем задачи, которую тебе поставил руководитель. Она нужна, чтобы ты мог планировать свой день (изначально крайний срок выбирает постановщик, но именно в этой задаче крайний срок выбирается автоматически сегодня, а ты можешь менять его, используя это поле крайнего срока как дату ближайшего контакта с этой задачей. Не забывай при этом выполнять её в срок, который тебе назначил руководитель.` values := url.Values{} values.Set("fields[TITLE]", "Копия "+task.Title) values.Set( "fields[DESCRIPTION]", taskDescriptionTemplate+"\n\n"+task.Description, ) values.Set("fields[RESPONSIBLE_ID]", strconv.Itoa(task.ResponsibleID)) values.Set("fields[CREATED_BY]", strconv.Itoa(task.ResponsibleID)) values.Set("fields[GROUP_ID]", strconv.Itoa(task.ProjectID)) values.Set("fields[PARENT_ID]", strconv.Itoa(task.ID)) values.Set("fields[DEADLINE]", time.Now().Format(time.RFC3339)) values.Set("fields[ALLOW_CHANGE_DEADLINE]", "Y") values.Set("fields[UF_AUTO_682289870673]", "Y") // Копия задачи = да values.Set("fields[TASK_CONTROL]", "N") values.Set("fields[MATCH_WORK_TIME]", "N") // Наблюдатели for i, id := range auditorIDs { values.Set( fmt.Sprintf("fields[AUDITORS][%d]", i), strconv.Itoa(id), ) } // for i, crm := range task.CRMElements { // values.Set( // fmt.Sprintf("fields[UF_CRM_TASK][%d]", i), // crm, // ) // } i := 0 for _, tag := range task.Tags { values.Set( fmt.Sprintf("fields[TAGS][%d]", i), tag.Title, ) i++ } for _, crmName := range CRMElementNames { values.Set( fmt.Sprintf("fields[TAGS][%d]", i), crmName, ) i++ } return "tasks.task.add?" + values.Encode() } func (s *Service) CreateTaskCopyAtomic( ctx context.Context, task TaskDetails, auditorIDs []int, CRMElementNames []string, ) error { addCmd := buildAddCopyCommand(task, auditorIDs, CRMElementNames) updateCmd := fmt.Sprintf( "tasks.task.update?taskId=%d&fields[UF_AUTO_889836441236]=$result[add_copy][task][id]", task.ID, ) batchPayload := map[string]interface{}{ "cmd": map[string]string{ "add_copy": addCmd, "link_original": updateCmd, }, } if err := s.call(ctx, "batch", batchPayload, nil); err != nil { return err } return nil } func (s *Service) GetCRMElementTitles( ctx context.Context, crmIDs []string, ) ([]string, error) { if len(crmIDs) == 0 { return nil, nil } cmd := make(map[string]string) index := 0 for _, crm := range crmIDs { parts := strings.SplitN(crm, "_", 2) if len(parts) != 2 { continue } prefix := parts[0] id := parts[1] var method string switch prefix { case "D": method = "crm.deal.get" case "L": method = "crm.lead.get" case "C": method = "crm.contact.get" case "CO": method = "crm.company.get" default: continue } cmdName := fmt.Sprintf("crm_%d", index) cmd[cmdName] = fmt.Sprintf("%s?id=%s", method, id) index++ } if len(cmd) == 0 { return nil, nil } payload := map[string]interface{}{ "cmd": cmd, } var batchResult struct { Result map[string]json.RawMessage `json:"result"` ResultError json.RawMessage `json:"result_error"` } if err := s.call(ctx, "batch", payload, &batchResult); err != nil { return nil, err } if len(batchResult.ResultError) > 0 { // Проверяем, это массив? var arr []interface{} if err := json.Unmarshal(batchResult.ResultError, &arr); err == nil { if len(arr) > 0 { return nil, fmt.Errorf("batch error: %+v", arr) } } else { // иначе это объект var obj map[string]interface{} if err := json.Unmarshal(batchResult.ResultError, &obj); err == nil { if len(obj) > 0 { return nil, fmt.Errorf("batch error: %+v", obj) } } } } titles := make([]string, 0, len(batchResult.Result)) for key := range cmd { var raw map[string]interface{} if err := json.Unmarshal(batchResult.Result[key], &raw); err != nil { continue } // Возможные варианты структуры ответа // Сделка/лид -> TITLE // Контакт -> NAME + LAST_NAME // Компания -> TITLE if title, ok := raw["TITLE"].(string); ok && title != "" { titles = append(titles, title) continue } name, _ := raw["NAME"].(string) lastName, _ := raw["LAST_NAME"].(string) fullName := strings.TrimSpace(name + " " + lastName) if fullName != "" { titles = append(titles, fullName) } } return titles, nil } type taskListResponse struct { Tasks []struct { ID int `json:"id,string"` Status int `json:"status,string"` } `json:"tasks"` } const ( TaskStatusSupposedly = 4 // ждет контроля TaskStatusCompleted = 5 // завершена ) func (s *Service) CompleteSubtasks(ctx context.Context, taskID int) error { // Получаем список подзадач var resp taskListResponse err := s.call( ctx, "tasks.task.list", map[string]interface{}{ "filter": map[string]interface{}{ "PARENT_ID": taskID, }, "select": []string{"ID", "STATUS"}, }, &resp, ) if err != nil { return fmt.Errorf("get subtasks: %w", err) } // Завершаем каждую подзадачу for _, task := range resp.Tasks { if task.Status == TaskStatusCompleted || task.Status == TaskStatusSupposedly { continue } if err := s.call( ctx, "tasks.task.complete", map[string]interface{}{ "taskId": task.ID, }, nil, ); err != nil { return fmt.Errorf("complete subtask %d: %w", task.ID, err) } } return nil }