bitrix_service/internal/bitrix/bitrix.go

773 lines
17 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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
}