Initial commit

This commit is contained in:
Dmitriy_Kravchenko 2026-04-27 16:27:47 +03:00
commit fec35d2110
10 changed files with 1328 additions and 0 deletions

7
.env copy Normal file
View File

@ -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

25
.vscode/launch.json vendored Normal file
View File

@ -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",
}
}
]
}

14
Dockerfile Normal file
View File

@ -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"]

65
bitrix_event.go Normal file
View File

@ -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
}

12
go.mod Normal file
View File

@ -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
)

19
go.sum Normal file
View File

@ -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=

766
internal/bitrix/bitrix.go Normal file
View File

@ -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
}

61
internal/obsids/cache.go Normal file
View File

@ -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)
}
}
}()
}

123
internal/obsids/storage.go Normal file
View File

@ -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
}
}
}()
}

236
main.go Normal file
View File

@ -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)
}