commit fec35d2110e880b28435e5c90dd85568e69b40eb Author: Dmitriy_Kravchenko Date: Mon Apr 27 16:27:47 2026 +0300 Initial commit diff --git a/.env copy b/.env copy new file mode 100644 index 0000000..f5f6384 --- /dev/null +++ b/.env copy @@ -0,0 +1,7 @@ +DB_CONN=postgres://btr_db_user:StrongPassword123@localhost:5432/btr_db +OBS_API_URL=https://script.google.com/macros/s/AKfycbwilIPLrUQR0hSFseTRQPyVQon4rO-TmXJ0bceovj9xwhC5GM3CelOtVnFAdlxFOqaQvQ/exec +DEPS_API_URL=https://script.google.com/macros/s/AKfycbyiRLAPyszxpYGCrwDreAJt3jxO4eXsNw31dylyMR_OBRr27FFhhYXl_1Uz_NanRUE6/exec +BITRIX_TASK_API_URL=https://thebest.bitrix24.ru/rest/334/748roorgdjcdji3f/ +LOAD_BALANCER_API_URL=https://45.10.40.213.nip.io/balancer/api/balancer/send +LOAD_BALANCER_PRIVATE_KEY=89bab1c15544e7bb667b773df786e65f9aed0bf173a84e66e2a88aec3f0014d89a289807c34f71c876b79f67997c9ac281ffd19d00fe8582ebcda97660bddaa3 +LOAD_BALANCER_PUBLIC_KEY=68929830b9a07e7c6fa1d4bdfbcafe798a50de4da2969e743fee690dfaec3fb4 \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..88eb064 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,25 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + + { + "name": "Launch Package", + "type": "go", + "request": "launch", + "mode": "auto", + "program": "${fileDirname}", + "env": { + "DB_CONN":"postgres://btr_db_user:StrongPassword123@localhost:5432/btr_db", + "OBS_API_URL":"https://script.google.com/macros/s/AKfycbwilIPLrUQR0hSFseTRQPyVQon4rO-TmXJ0bceovj9xwhC5GM3CelOtVnFAdlxFOqaQvQ/exec", + "DEPS_API_URL": "https://script.google.com/macros/s/AKfycbyiRLAPyszxpYGCrwDreAJt3jxO4eXsNw31dylyMR_OBRr27FFhhYXl_1Uz_NanRUE6/exec", + "BITRIX_TASK_API_URL":"https://thebest.bitrix24.ru/rest/334/748roorgdjcdji3f/", + "LOAD_BALANCER_API_URL":"https://45.10.40.213.nip.io/balancer/api/balancer/send", + "LOAD_BALANCER_PRIVATE_KEY":"89bab1c15544e7bb667b773df786e65f9aed0bf173a84e66e2a88aec3f0014d89a289807c34f71c876b79f67997c9ac281ffd19d00fe8582ebcda97660bddaa3", + "LOAD_BALANCER_PUBLIC_KEY":"68929830b9a07e7c6fa1d4bdfbcafe798a50de4da2969e743fee690dfaec3fb4", + } + } + ] +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..b6bd374 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM golang:1.25-alpine AS builder + +WORKDIR /app + +COPY go.mod ./ + +COPY . . +RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o app + +FROM alpine:latest +WORKDIR /root/ +COPY --from=builder /app/app . + +CMD ["./app"] diff --git a/bitrix_event.go b/bitrix_event.go new file mode 100644 index 0000000..ebf3a0a --- /dev/null +++ b/bitrix_event.go @@ -0,0 +1,65 @@ +package main + +import ( + "context" + "errors" + "fmt" + "net/url" + "strconv" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +type BitrixEvent struct { + eventId int + eventType string + taskId int + eventTimestamp time.Time +} + +func (e *BitrixEvent) GetTaskId() int { + return e.taskId +} + +func (e *BitrixEvent) GetEventId() int { + return e.eventId +} + +func (e *BitrixEvent) GetEventType() string { + return e.eventType +} + +func CreateFromEventDB(ctx context.Context, pool *pgxpool.Pool) (*BitrixEvent, error) { + const query = ` + SELECT id, event_type, event_timestamp, request_body + FROM event_queue + WHERE status = 'pending' + ORDER BY event_timestamp + LIMIT 1; + ` + + var event BitrixEvent + var eventDataURLEncoded string + err := pool.QueryRow(ctx, query).Scan(&event.eventId, &event.eventType, &event.eventTimestamp, &eventDataURLEncoded) + + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + return nil, fmt.Errorf("error during event pull from db: %w", err) + } + + eventDataDecoded, err := url.ParseQuery(eventDataURLEncoded) + if err != nil { + return nil, fmt.Errorf("request body is malformed: %w", err) + } + + event.taskId, err = strconv.Atoi(eventDataDecoded.Get("data[FIELDS_AFTER][ID]")) + if err != nil { + return nil, fmt.Errorf("task id is malformed or not found: %w", err) + } + + return &event, nil +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..0ed59e5 --- /dev/null +++ b/go.mod @@ -0,0 +1,12 @@ +module event_handler + +go 1.25.0 + +require ( + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/pgx/v5 v5.8.0 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + golang.org/x/sync v0.17.0 // indirect + golang.org/x/text v0.29.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..2aca163 --- /dev/null +++ b/go.sum @@ -0,0 +1,19 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.8.0 h1:TYPDoleBBme0xGSAX3/+NujXXtpZn9HBONkQC7IEZSo= +github.com/jackc/pgx/v5 v5.8.0/go.mod h1:QVeDInX2m9VyzvNeiCJVjCkNFqzsNb43204HshNSZKw= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk= +golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/bitrix/bitrix.go b/internal/bitrix/bitrix.go new file mode 100644 index 0000000..ed30ae5 --- /dev/null +++ b/internal/bitrix/bitrix.go @@ -0,0 +1,766 @@ +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 + + // --- Определяем связанную задачу --- + var linkedTaskID int + + if current.IsCopyString == "1" { + // если это копия — связанная это главная + linkedTaskID = current.ParentID + } else { + // если это главная — связанная это копия + linkedTaskID = current.CopyID + } + + if linkedTaskID == 0 { + return nil + } + + getPayload["taskId"] = linkedTaskID + var getRespLinked struct { + Task taskInfo `json:"task"` + } + if err := s.call(ctx, "tasks.task.get", getPayload, &getRespLinked); err != nil { + if strings.Contains(err.Error(), "0: ") { + return nil + } + return err + } + linked := getRespLinked.Task + if linked.TaskControl == "" { + return nil + } + + var newStatus int + if linked.Status != current.Status { + if current.Status == 5 || current.Status == 4 { + if linked.TaskControl == "" || linked.TaskControl != "Y" { + newStatus = 5 + } else { + newStatus = 4 + } + } + if current.Status == 2 { + newStatus = 2 + } + } + + payload := map[string]interface{}{ + "taskId": linkedTaskID, + "fields": map[string]interface{}{ + "STATUS": newStatus, + }, + } + + var resp struct { + Result interface{} `json:"result"` + } + + return s.call(ctx, "tasks.task.update", payload, &resp) +} + +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"` + 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", + }, + } + + 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 +} diff --git a/internal/obsids/cache.go b/internal/obsids/cache.go new file mode 100644 index 0000000..9300141 --- /dev/null +++ b/internal/obsids/cache.go @@ -0,0 +1,61 @@ +package obsids + +import ( + "encoding/json" + "net/http" + "sync/atomic" + "time" +) + +func fetchIDs(sourceURL string) []int { + response, err := http.Get(sourceURL) + if err != nil { + return []int{} + } + defer response.Body.Close() + + var ids []int + err = json.NewDecoder(response.Body).Decode(&ids) + if err != nil { + return []int{} + } + + return ids +} + +type Cache struct { + value atomic.Value // всегда хранит []int + interval time.Duration + sourceURL string +} + +func NewCache(sourceURL string, interval time.Duration, defaultValue []int) *Cache { + c := &Cache{value: atomic.Value{}, interval: interval, sourceURL: sourceURL} + + c.value.Store(defaultValue) + + fetchedIDs := fetchIDs(c.sourceURL) + if len(fetchedIDs) > 0 { + c.value.Store(fetchedIDs) + } + + return c +} + +func (c *Cache) Get() []int { + return c.value.Load().([]int) +} + +func (c *Cache) StartRefresh() { + go func() { + hourTicker := time.NewTicker(c.interval) + defer hourTicker.Stop() + + for range hourTicker.C { + fetchedIDs := fetchIDs(c.sourceURL) + if len(fetchedIDs) > 0 { + c.value.Store(fetchedIDs) + } + } + }() +} diff --git a/internal/obsids/storage.go b/internal/obsids/storage.go new file mode 100644 index 0000000..d09fad5 --- /dev/null +++ b/internal/obsids/storage.go @@ -0,0 +1,123 @@ +package obsids + +import ( + "encoding/json" + "io" + "net/http" + "strconv" + "sync/atomic" + "time" +) + +type IntMap struct { + data map[int][]int +} + +func NewIntMapFromJSON(b []byte) (*IntMap, error) { + temp := map[string][]int{} + + if err := json.Unmarshal(b, &temp); err != nil { + return nil, err + } + + m := make(map[int][]int, len(temp)) + + for k, v := range temp { + i, err := strconv.Atoi(k) + if err != nil { + return nil, err + } + m[i] = v + } + + return &IntMap{data: m}, nil +} + +func (m *IntMap) GetValues(keys []int) []int { + set := make(map[int]struct{}) + + for _, k := range keys { + if vals, ok := m.data[k]; ok { + for _, v := range vals { + set[v] = struct{}{} + } + } + } + + res := make([]int, 0, len(set)) + for v := range set { + res = append(res, v) + } + + return res +} + +func (m *IntMap) Keys() []int { + keys := make([]int, 0, len(m.data)) + + for k := range m.data { + keys = append(keys, k) + } + + return keys +} + +type Storage struct { + value atomic.Value // хранит *IntMap +} + +func NewStorage() *Storage { + s := &Storage{} + s.value.Store(&IntMap{data: map[int][]int{}}) + return s +} + +func (s *Storage) GetValues(keys []int) []int { + m := s.value.Load().(*IntMap) + return m.GetValues(keys) +} + +func (s *Storage) Keys() []int { + m := s.value.Load().(*IntMap) + return m.Keys() +} + +func (s *Storage) UpdateFromJSON(b []byte) error { + m, err := NewIntMapFromJSON(b) + if err != nil { + return err + } + + s.value.Store(m) + return nil +} + +func (s *Storage) UpdateFromURL(url string) error { + resp, err := http.Get(url) + if err != nil { + return err + } + + body, err := io.ReadAll(resp.Body) + resp.Body.Close() + if err != nil { + return err + } + + _ = s.UpdateFromJSON(body) + return nil +} + +func (s *Storage) StartRefresh(url string, interval time.Duration) { + go func() { + hourTicker := time.NewTicker(interval) + defer hourTicker.Stop() + + for range hourTicker.C { + err := s.UpdateFromURL(url) + if err != nil { + continue + } + } + }() +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..d9cdfea --- /dev/null +++ b/main.go @@ -0,0 +1,236 @@ +package main + +import ( + "context" + "event_handler/internal/bitrix" + "event_handler/internal/obsids" + "fmt" + "os" + "os/signal" + "strings" + "syscall" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +type ConfigData struct { + dbConnectionString string + obsAPIURL string + BITRIX_TASK_API_URL string + DEPS_API_URL string + LOAD_BALANCER_API_URL string + LOAD_BALANCER_PRIVATE_KEY string + LOAD_BALANCER_PUBLIC_KEY string +} + +func readConfig() ConfigData { + var config ConfigData + config.dbConnectionString = os.Getenv("DB_CONN") + config.obsAPIURL = os.Getenv("OBS_API_URL") + config.BITRIX_TASK_API_URL = os.Getenv("BITRIX_TASK_API_URL") + config.DEPS_API_URL = os.Getenv("DEPS_API_URL") + config.LOAD_BALANCER_API_URL = os.Getenv("LOAD_BALANCER_API_URL") + config.LOAD_BALANCER_PRIVATE_KEY = os.Getenv("LOAD_BALANCER_PRIVATE_KEY") + config.LOAD_BALANCER_PUBLIC_KEY = os.Getenv("LOAD_BALANCER_PUBLIC_KEY") + return config +} + +func ensureAllObsInAuditors(auditorIDs, obsIDs []int) ([]int, bool) { + // Множество уже существующих auditorIDs + seen := make(map[int]struct{}, len(auditorIDs)) + + for _, id := range auditorIDs { + seen[id] = struct{}{} + } + + // Добавляем отсутствующие obsIDs + var isUpdateNeeded bool = false + for _, id := range obsIDs { + if _, exists := seen[id]; !exists { + isUpdateNeeded = true + auditorIDs = append(auditorIDs, id) + seen[id] = struct{}{} + } + } + + return auditorIDs, isUpdateNeeded +} + +func processTaskChangeEvent(ctx context.Context, event *BitrixEvent, mandatoryAuditors *[]int, bitrixService *bitrix.Service) error { + changedByID, auditorIDS, err := bitrixService.GetTaskUsers(ctx, event.GetTaskId()) + fmt.Println(changedByID) + if err != nil { + return err + } + + obsIDs := *mandatoryAuditors + auditorIDs, updateNeeded := ensureAllObsInAuditors(auditorIDS, obsIDs) + + err = bitrixService.SyncTaskCompletion(ctx, event.GetTaskId()) + if err != nil { + return err + } + + if !updateNeeded { + return nil + } + err = bitrixService.SetTaskAuditors(ctx, event.GetTaskId(), auditorIDs) + if err != nil { + return err + } + + return nil +} + +func processNewTaskEvent(ctx context.Context, event *BitrixEvent, mandatoryAuditors *[]int, bitrixService *bitrix.Service) error { + taskInfo, err := bitrixService.GetTaskDetails(ctx, event.GetTaskId()) + if taskInfo == nil { + return nil + } + if err != nil { + return err + } + if taskInfo.IsCopy != nil && *taskInfo.IsCopy == "1" { + return nil + } + if taskInfo.CopyID != nil { + return nil + } + + changedByID, auditorIDS, err := bitrixService.GetTaskUsers(ctx, event.GetTaskId()) + fmt.Println(changedByID) + if err != nil { + return err + } + obsIDs := *mandatoryAuditors + auditorIDS, _ = ensureAllObsInAuditors(auditorIDS, obsIDs) + + bitrixService.SetTaskAuditors(ctx, event.GetTaskId(), auditorIDS) + + CRMElementNames, err := bitrixService.GetCRMElementTitles(ctx, taskInfo.CRMElements) + + err = bitrixService.CreateTaskCopyAtomic(ctx, *taskInfo, auditorIDS, CRMElementNames) + if err != nil { + return err + } + + return nil +} + +func isTaskControlNeeded(taskName string) bool { + codeSubstrEnd := strings.Index(taskName, "#") + return codeSubstrEnd != -1 +} + +func isTaskControl(taskName string) bool { + codeSubstrEnd := strings.Index(taskName, "#") + codeSubstr := taskName[0:codeSubstrEnd] + return strings.Contains(codeSubstr, "В") || strings.Contains(codeSubstr, "П") +} + +func processEvent(ctx context.Context, event *BitrixEvent, fullObsConfigStorage *obsids.Storage, config *ConfigData) error { + bitrixService := bitrix.NewService(config.BITRIX_TASK_API_URL, config.LOAD_BALANCER_API_URL, config.LOAD_BALANCER_PRIVATE_KEY, config.LOAD_BALANCER_PUBLIC_KEY) + + taskInfo, err := bitrixService.GetTaskInfo(ctx, event.GetTaskId()) + if err != nil { + return nil + } + //вебхуки изменяют задачи от имени Технического аккаунта в Битриксе. Его ID - 334 + if bitrixService.IsSelfRequest(taskInfo.ChangedBy, 334) { + return nil + } + + if event.GetEventType() == "ONTASKADD" { + if isTaskControlNeeded(taskInfo.TaskName) { + isControl := isTaskControl(taskInfo.TaskName) + err = bitrixService.SetTaskControl(ctx, event.GetTaskId(), isControl) + if err != nil { + return nil + } + } + } + + isTaskValid, userDeps, err := bitrixService.ValidateTaskUserDeps(ctx, taskInfo.ResponsibleID, fullObsConfigStorage.Keys()) + if err != nil { + return err + } + if !isTaskValid { + return nil + } + + mandatoryAuditors := fullObsConfigStorage.GetValues(userDeps) + + switch event.GetEventType() { + case "ONTASKUPDATE": + err = processTaskChangeEvent(ctx, event, &mandatoryAuditors, bitrixService) + case "ONTASKADD": + err = processNewTaskEvent(ctx, event, &mandatoryAuditors, bitrixService) + } + + if err != nil { + return err + } + return nil +} + +func setEventDone(ctx context.Context, pool *pgxpool.Pool, event *BitrixEvent) { + const query = `UPDATE event_queue SET status = 'done' WHERE id = $1;` + + _, err := pool.Exec(ctx, query, event.GetEventId()) + if err != nil { + panic(err) + } +} + +func pollEventQueue(ctx context.Context, pool *pgxpool.Pool, fullObsConfigStorage *obsids.Storage, config *ConfigData) { + ticker := time.NewTicker(1 * time.Second) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + event, err := CreateFromEventDB(ctx, pool) + if err != nil { + panic(err) + } + if event == nil { + continue + } + + err = processEvent(ctx, event, fullObsConfigStorage, config) + if err != nil { + fmt.Println(err) + break + } + setEventDone(ctx, pool, event) + } + } +} + +func main() { + config := readConfig() + + ctx, cancel := context.WithCancel(context.Background()) + + sigs := make(chan os.Signal, 1) + signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM) + go func() { + <-sigs + cancel() + }() + + pool, err := pgxpool.New(ctx, config.dbConnectionString) + if err != nil { + panic(err) + } + defer pool.Close() + + fullObsConfigStorage := obsids.NewStorage() + fullObsConfigStorage.UpdateFromURL(config.obsAPIURL) + fullObsConfigStorage.StartRefresh(config.obsAPIURL, 1*time.Hour) + + pollEventQueue(ctx, pool, fullObsConfigStorage, &config) +}