diff --git a/service/rest_telephony_service/handlers/telephony/bitrix.go b/service/rest_telephony_service/handlers/telephony/bitrix.go index 391205f..6b77faf 100644 --- a/service/rest_telephony_service/handlers/telephony/bitrix.go +++ b/service/rest_telephony_service/handlers/telephony/bitrix.go @@ -2,79 +2,336 @@ package telephonyservice import ( "bytes" + "context" "encoding/json" + "errors" "fmt" + "io" "net/http" - - "github.com/sirupsen/logrus" + "net/url" + "path" + "strconv" + "strings" + "time" ) -// URL вебхука, который ты создал в Битрикс24 +// URL входящего вебхука Битрикс24 (можно переопределить переменной BITRIX_WEBHOOK_URL). const bitrixWebhookURL = "https://thebest.bitrix24.ru/rest/292/paz20o3316e6cfe7/" -// BxContactListResp описывает структуру ответа Битрикс24 при поиске -type BxContactListResp struct { - Result []struct { - ID string `json:"ID"` - CompanyID string `json:"COMPANY_ID"` - } `json:"result"` +// Максимальный размер записи, которую прикладываем файлом (в base64 станет ~на треть больше). +const maxRecordingBytes = 20 << 20 + +var errContactNotFound = errors.New("contact not found in Bitrix24") +var errRecordingTooBig = errors.New("recording is too big to attach") + +// bxError — ошибка, которую вернул сам Битрикс24 (поле "error" в ответе). +type bxError struct { + Code string + Desc string + HTTP int } -// PushSmsToBitrix ищет контакт по номеру и пушит SMS в его таймлайн -func PushSmsToBitrix(clientNumber, text string, direction int) { - // 🚀 Выполняем в отдельной горутине, чтобы мгновенно ответить АТС (200 OK) - // и не блокировать работу сервера, пока ждем ответа от Битрикса - go func() { - // 1. Ищем контакт по номеру телефона - searchReqBody, _ := json.Marshal(map[string]interface{}{ - "filter": map[string]string{"PHONE": clientNumber}, - "select": []string{"ID", "COMPANY_ID"}, - }) - - resp, err := http.Post(bitrixWebhookURL+"crm.contact.list.json", "application/json", bytes.NewBuffer(searchReqBody)) - if err != nil { - logrus.Errorf("Bitrix24 search contact error: %v", err) - return - } - defer resp.Body.Close() - - var listResp BxContactListResp - if err := json.NewDecoder(resp.Body).Decode(&listResp); err != nil { - logrus.Errorf("Bitrix24 decode error: %v", err) - return - } - - if len(listResp.Result) == 0 { - logrus.Infof("Bitrix24: Contact with phone %s not found. Skipping timeline comment.", clientNumber) - return - } - - // Берем ID первого найденного контакта - contactID := listResp.Result[0].ID - - // 2. Формируем красивый текст комментария с использованием BBCode (Битрикс его поддерживает) - dirStr := "[b]📥 Входящее SMS[/b]" - if direction == 1 { - dirStr = "[b]📤 Исходящее SMS[/b]" - } - - comment := fmt.Sprintf("%s\nНомер: %s\n\n%s", dirStr, clientNumber, text) - - addReqBody, _ := json.Marshal(map[string]interface{}{ - "fields": map[string]interface{}{ - "ENTITY_ID": contactID, - "ENTITY_TYPE": "contact", // События контакта автоматически видны и в привязанной Компании/Сделке - "COMMENT": comment, - }, - }) - - addResp, err := http.Post(bitrixWebhookURL+"crm.timeline.comment.add.json", "application/json", bytes.NewBuffer(addReqBody)) - if err != nil { - logrus.Errorf("Bitrix24 add comment error: %v", err) - return - } - defer addResp.Body.Close() - - logrus.Infof("Successfully pushed SMS to Bitrix24 timeline for contact ID %s", contactID) - }() +func (e *bxError) Error() string { + return fmt.Sprintf("bitrix error %s: %s (http %d)", e.Code, e.Desc, e.HTTP) +} + +// isPermanent — повторять запрос бессмысленно. +func isPermanent(err error) bool { + if errors.Is(err, errContactNotFound) { + return true + } + var be *bxError + if errors.As(err, &be) { + switch be.Code { + case "OWNER_NOT_FOUND", "INVALID_ARG_VALUE", "100": + return true + } + } + return false +} + +// BitrixClient — клиент входящего вебхука Битрикс24. +type BitrixClient struct { + baseURL string + http *http.Client + dl *http.Client // скачивание записей +} + +func NewBitrixClient(webhookURL string) *BitrixClient { + webhookURL = strings.TrimSpace(webhookURL) + if !strings.HasSuffix(webhookURL, "/") { + webhookURL += "/" + } + return &BitrixClient{ + baseURL: webhookURL, + http: &http.Client{Timeout: 60 * time.Second}, + dl: &http.Client{Timeout: 90 * time.Second}, + } +} + +type bxResponse struct { + Result json.RawMessage `json:"result"` + Error string `json:"error"` + ErrorDescription string `json:"error_description"` +} + +func (c *BitrixClient) call(ctx context.Context, method string, params interface{}) (json.RawMessage, error) { + body, err := json.Marshal(params) + if err != nil { + return nil, err + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+method+".json", bytes.NewReader(body)) + if err != nil { + return nil, errors.New("bitrix: bad request") + } + req.Header.Set("Content-Type", "application/json") + + resp, err := c.http.Do(req) + if err != nil { + // url.Error содержит полный URL с секретом вебхука — не пропускаем его в логи. + var ue *url.Error + if errors.As(err, &ue) { + return nil, fmt.Errorf("bitrix %s: %w", method, ue.Err) + } + return nil, fmt.Errorf("bitrix %s: request failed", method) + } + defer resp.Body.Close() + + raw, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20)) + if err != nil { + return nil, fmt.Errorf("bitrix %s: read body: %w", method, err) + } + + var r bxResponse + jsonErr := json.Unmarshal(raw, &r) + if r.Error != "" { + return nil, &bxError{Code: r.Error, Desc: r.ErrorDescription, HTTP: resp.StatusCode} + } + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("bitrix %s: http %d", method, resp.StatusCode) + } + if jsonErr != nil { + return nil, fmt.Errorf("bitrix %s: bad json: %w", method, jsonErr) + } + return r.Result, nil +} + +// FindContact ищет контакт по номеру. Возвращает ID первого найденного. +func (c *BitrixClient) FindContact(ctx context.Context, number string) (int, error) { + variants := phoneVariants(number) + if len(variants) == 0 { + return 0, errContactNotFound + } + + // 1) crm.duplicate.findbycomm — ищет по телефону с учётом нормализации Битрикса. + raw, err := c.call(ctx, "crm.duplicate.findbycomm", map[string]interface{}{ + "type": "PHONE", + "values": variants, + "entity_type": "CONTACT", + }) + if err == nil { + // При пустом результате Битрикс возвращает [] вместо объекта — это не ошибка. + var m map[string][]FlexInt + if json.Unmarshal(raw, &m) == nil && len(m["CONTACT"]) > 0 { + return int(m["CONTACT"][0]), nil + } + } else { + var be *bxError + if !errors.As(err, &be) { + return 0, err // сеть/5xx — пусть вызывающий повторит + } + } + + // 2) Запасной вариант: точное совпадение по каждому формату номера. + for _, v := range variants { + raw, err := c.call(ctx, "crm.contact.list", map[string]interface{}{ + "filter": map[string]string{"PHONE": v}, + "select": []string{"ID"}, + "order": map[string]string{"ID": "ASC"}, + }) + if err != nil { + return 0, err + } + var list []struct { + ID FlexInt `json:"ID"` + } + if json.Unmarshal(raw, &list) == nil && len(list) > 0 { + return int(list[0].ID), nil + } + } + return 0, errContactNotFound +} + +// AddComment добавляет комментарий в таймлайн контакта. +// Если fileB64 не пуст, файл прикладывается к комментарию (FILES). +func (c *BitrixClient) AddComment(ctx context.Context, contactID int, text, fileName, fileB64 string) error { + fields := map[string]interface{}{ + "ENTITY_ID": contactID, + "ENTITY_TYPE": "contact", + "COMMENT": text, + } + if fileB64 != "" { + fields["FILES"] = [][]string{{fileName, fileB64}} + } + raw, err := c.call(ctx, "crm.timeline.comment.add", map[string]interface{}{"fields": fields}) + if err != nil { + return err + } + id, convErr := strconv.Atoi(strings.TrimSpace(string(raw))) + if convErr != nil || id <= 0 { + return fmt.Errorf("bitrix crm.timeline.comment.add: unexpected result %q", string(raw)) + } + return nil +} + +// DownloadRecording скачивает запись разговора. Возвращает содержимое и имя файла с расширением. +func (c *BitrixClient) DownloadRecording(ctx context.Context, recURL, baseName string) ([]byte, string, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, recURL, nil) + if err != nil { + return nil, "", errors.New("recording: bad url") + } + resp, err := c.dl.Do(req) + if err != nil { + // url.Error содержит адрес записи (возможно, с токеном) — не пускаем его в логи. + var ue *url.Error + if errors.As(err, &ue) { + return nil, "", fmt.Errorf("recording download: %w", ue.Err) + } + return nil, "", errors.New("recording download failed") + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, "", fmt.Errorf("recording download: http %d", resp.StatusCode) + } + if resp.ContentLength > maxRecordingBytes { + return nil, "", errRecordingTooBig + } + data, err := io.ReadAll(io.LimitReader(resp.Body, maxRecordingBytes+1)) + if err != nil { + return nil, "", fmt.Errorf("recording download: %w", err) + } + if len(data) > maxRecordingBytes { + return nil, "", errRecordingTooBig + } + if len(data) == 0 { + return nil, "", errors.New("recording download: empty body") + } + return data, baseName + recordingExt(resp.Header.Get("Content-Type"), resp.Request.URL.Path), nil +} + +func recordingExt(contentType, urlPath string) string { + ct := strings.ToLower(strings.TrimSpace(strings.SplitN(contentType, ";", 2)[0])) + switch ct { + case "audio/mpeg", "audio/mp3": + return ".mp3" + case "audio/wav", "audio/x-wav", "audio/wave": + return ".wav" + case "audio/mp4", "audio/x-m4a", "audio/aac": + return ".m4a" + case "audio/ogg": + return ".ogg" + case "audio/amr": + return ".amr" + } + switch ext := strings.ToLower(path.Ext(urlPath)); ext { + case ".mp3", ".wav", ".m4a", ".ogg", ".amr", ".aac": + return ext + } + return ".mp3" +} + +// ---------- Телефоны ---------- + +func digitsOnly(s string) string { + var b strings.Builder + for _, r := range s { + if r >= '0' && r <= '9' { + b.WriteRune(r) + } + } + return b.String() +} + +// phoneVariants возвращает варианты записи номера, под которыми он может лежать в Битриксе. +func phoneVariants(raw string) []string { + d := digitsOnly(raw) + if d == "" { + return nil + } + if len(d) == 11 && d[0] == '8' { + d = "7" + d[1:] + } else if len(d) == 10 { + d = "7" + d + } + if len(d) == 11 && d[0] == '7' { + return []string{"+" + d, d, "8" + d[1:]} + } + return []string{"+" + d, d} +} + +func maskPhone(raw string) string { + d := digitsOnly(raw) + if len(d) <= 4 { + return "***" + } + return "***" + d[len(d)-4:] +} + +// ---------- Тексты комментариев (BBCode) ---------- + +func formatDuration(sec int64) string { + if sec < 0 { + sec = 0 + } + return fmt.Sprintf("%d:%02d", sec/60, sec%60) +} + +func formatTime(unix int64, loc *time.Location) string { + return time.Unix(unix, 0).In(loc).Format("02.01.2006 15:04") +} + +func buildCallComment(e *callEvent, loc *time.Location) string { + answered := int64(e.Answered) == 1 + incoming := int64(e.Direction) == 0 + + var title string + switch { + case incoming && answered: + title = "📞 Входящий звонок" + case incoming && !answered: + title = "📵 Пропущенный звонок" + case !incoming && answered: + title = "📤 Исходящий звонок" + default: + title = "📤 Исходящий звонок (без ответа)" + } + + started := int64(e.StartTime) + if started == 0 { + started = int64(e.EventCreated) + } + + var b strings.Builder + fmt.Fprintf(&b, "[b]%s[/b]\nНомер: %s\n", title, e.ClientNumber) + if e.ClientName != "" { + fmt.Fprintf(&b, "Имя в телефоне: %s\n", e.ClientName) + } + fmt.Fprintf(&b, "Время: %s\n", formatTime(started, loc)) + if answered { + fmt.Fprintf(&b, "Длительность: %s\n", formatDuration(int64(e.Duration))) + } + if e.SrcNumber != "" { + fmt.Fprintf(&b, "Линия: %s\n", e.SrcNumber) + } + return strings.TrimRight(b.String(), "\n") +} + +func buildSMSComment(e *callEvent, loc *time.Location) string { + title := "📥 Входящее SMS" + if int64(e.Direction) == 1 { + title = "📤 Исходящее SMS" + } + return fmt.Sprintf("[b]%s[/b]\nНомер: %s\nВремя: %s\n\n%s", + title, e.ClientNumber, formatTime(int64(e.EventCreated), loc), e.Text) } diff --git a/service/rest_telephony_service/handlers/telephony/handlers.go b/service/rest_telephony_service/handlers/telephony/handlers.go index 430519f..71342b1 100644 --- a/service/rest_telephony_service/handlers/telephony/handlers.go +++ b/service/rest_telephony_service/handlers/telephony/handlers.go @@ -2,61 +2,136 @@ package telephonyservice import ( "bitrix_balancer_api/core/typescore" - "bytes" "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" "errors" + "fmt" "io" "net/http" - "rest_telephony_service/handlers" typesm "rest_telephony_service/types" "strconv" + "strings" "time" "github.com/sirupsen/logrus" ) -// WebhookTelephonyHandler принимает события от АТС +const ( + eventCallStart = 1 + eventCallAnswer = 2 + eventCallFinish = 4 + eventSMS = 32 +) + +func truncate(b []byte, n int) string { + if len(b) > n { + return string(b[:n]) + "..." + } + return string(b) +} + +func smsKey(e *callEvent) string { + h := sha256.Sum256([]byte(fmt.Sprintf("%s|%d|%d|%s", e.ClientNumber, e.EventCreated, e.Direction, e.Text))) + return "sms:" + hex.EncodeToString(h[:12]) +} + +func callKey(e *callEvent) string { + if e.DBCallID != "" { + return "call:db:" + string(e.DBCallID) + } + return fmt.Sprintf("call:pbx:%s:%d", e.EventPbxCallID, e.EndTime) +} + +// WebhookTelephonyHandler принимает события от «Мои Звонки» (call.finish, sms.message). func (s *TelephonyReg) WebhookTelephonyHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { - var req typesm.TelephonyWebhookReq - - body, _ := io.ReadAll(r.Body) - logrus.Infof("webhook raw: %s", string(body)) - r.Body = io.NopCloser(bytes.NewReader(body)) - r.ContentLength = int64(len(body)) - - // Используем ваш стандартный парсер тела запроса - if err := handlers.ParseRequestBodyPost(r, &req); err != nil { + defer r.Body.Close() + body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) + if err != nil { + logrus.Errorf("webhook read error: %v", err) return nil, errors.New("invalid request body") } - - // Игнорируем всё, кроме SMS (event_type == 32) - if req.Event.EventType != 32 { - return map[string]string{"status": "ignored", "reason": "not an SMS event"}, nil + if s.debugRaw { + logrus.Infof("webhook raw: %s", truncate(body, 4000)) } - eventTime := time.Unix(req.Event.EventCreated, 0) + var req webhookReq + if err := json.Unmarshal(body, &req); err != nil { + logrus.Errorf("webhook parse error: %v; body: %s", err, truncate(body, 500)) + return nil, errors.New("invalid request body") + } + ev := &req.Event + + switch int(ev.EventType) { + case eventSMS: + return s.handleSMS(&req, ev) + case eventCallFinish: + return s.handleCallFinish(ev) + case eventCallStart, eventCallAnswer: + // start/answer не нужны: call.finish содержит всю информацию о звонке + return map[string]string{"status": "ignored", "reason": "call start/answer are not used"}, nil + default: + return map[string]string{"status": "ignored", "reason": "unsupported event type"}, nil + } +} + +func (s *TelephonyReg) handleSMS(req *webhookReq, ev *callEvent) (interface{}, error) { + accountID := string(req.Webhook.AccountID) + userID := string(req.Webhook.UserID) + number := string(ev.ClientNumber) + direction := int(ev.Direction) + text := ev.Text + eventTime := time.Unix(int64(ev.EventCreated), 0) smsLog := &typescore.SmsLog{ - AccountID: &req.Webhook.AccountID, - UserID: &req.Webhook.UserID, - ClientNumber: &req.Event.ClientNumber, - Direction: &req.Event.Direction, - Text: &req.Event.Text, + AccountID: &accountID, + UserID: &userID, + ClientNumber: &number, + Direction: &direction, + Text: &text, EventCreated: &eventTime, } - // Сохраняем SMS в БД - err := s.ipc.Database.SMSLog.CreateSmsLogDB(context.Background(), nil, smsLog) - if err != nil { + // Ошибка БД не должна лишать клиента записи в Битриксе. + if err := s.ipc.Database.SMSLog.CreateSmsLogDB(context.Background(), nil, smsLog); err != nil { logrus.Errorf("Failed to save SMS log: %v", err) - return nil, errors.New("database error") } - // 🆕 Отправляем SMS в карточку Битрикс24 (выполнится асинхронно) - PushSmsToBitrix(*smsLog.ClientNumber, *smsLog.Text, *smsLog.Direction) + queued := s.sync.Enqueue(&syncJob{ + Key: smsKey(ev), + Kind: "sms", + Number: number, + Comment: buildSMSComment(ev, s.loc), + }) + logrus.Infof("SMS from %s accepted (queued=%v)", maskPhone(number), queued) + return map[string]interface{}{"status": "success", "queued": queued}, nil +} - logrus.Infof("Successfully logged SMS from client %s", req.Event.ClientNumber) - return map[string]string{"status": "success"}, nil +func (s *TelephonyReg) handleCallFinish(ev *callEvent) (interface{}, error) { + number := string(ev.ClientNumber) + + job := &syncJob{ + Key: callKey(ev), + Kind: "call", + Number: number, + Comment: buildCallComment(ev, s.loc), + } + if int64(ev.Answered) == 1 && (strings.HasPrefix(ev.Recording, "https://") || strings.HasPrefix(ev.Recording, "http://")) { + started := int64(ev.StartTime) + if started == 0 { + started = int64(ev.EventCreated) + } + dir := "in" + if int64(ev.Direction) == 1 { + dir = "out" + } + job.RecordingURL = ev.Recording + job.FileBase = fmt.Sprintf("call_%s_%s_%s", dir, time.Unix(started, 0).In(s.loc).Format("20060102_1504"), digitsOnly(number)) + } + queued := s.sync.Enqueue(job) + logrus.Infof("Call with %s accepted (answered=%d, queued=%v)", maskPhone(number), ev.Answered, queued) + return map[string]interface{}{"status": "success", "queued": queued}, nil } // GetSmsReportHandler отдает список SMS для Google Script diff --git a/service/rest_telephony_service/handlers/telephony/queue.go b/service/rest_telephony_service/handlers/telephony/queue.go new file mode 100644 index 0000000..037c046 --- /dev/null +++ b/service/rest_telephony_service/handlers/telephony/queue.go @@ -0,0 +1,195 @@ +package telephonyservice + +import ( + "context" + "encoding/base64" + "errors" + "fmt" + "sync" + "time" + + "github.com/sirupsen/logrus" +) + +const ( + queueSize = 2000 + maxAttempts = 8 + dedupTTL = 48 * time.Hour + bitrixPause = 600 * time.Millisecond // у входящих вебхуков Битрикса лимит ~2 запроса/сек +) + +var retryDelays = []time.Duration{ + 10 * time.Second, 30 * time.Second, 2 * time.Minute, + 10 * time.Minute, 30 * time.Minute, time.Hour, 2 * time.Hour, +} + +type syncJob struct { + Key string // ключ дедупликации + Kind string // "call" | "sms" + Number string + Comment string + ContactID int + Attempts int + + // Запись разговора (только для звонков) + RecordingURL string + FileBase string // имя файла без расширения + fileName string + fileB64 string + linkFallback bool +} + +// BitrixSync — очередь доставки в таймлайн Битрикс24: дедупликация, повторы с задержкой. +// Очередь в памяти: при перезапуске сервиса недоставленные записи теряются. +type BitrixSync struct { + bx *BitrixClient + queue chan *syncJob + + mu sync.Mutex + seen map[string]time.Time +} + +func NewBitrixSync(bx *BitrixClient) *BitrixSync { + s := &BitrixSync{ + bx: bx, + queue: make(chan *syncJob, queueSize), + seen: make(map[string]time.Time), + } + go s.worker() + return s +} + +// Enqueue возвращает false, если событие уже обрабатывалось или очередь переполнена. +func (s *BitrixSync) Enqueue(job *syncJob) bool { + if !s.markSeen(job.Key) { + return false + } + select { + case s.queue <- job: + return true + default: + logrus.Errorf("bitrix: queue is full, dropping %s %s", job.Kind, job.Key) + s.forget(job.Key) + return false + } +} + +func (s *BitrixSync) markSeen(key string) bool { + s.mu.Lock() + defer s.mu.Unlock() + + now := time.Now() + if len(s.seen) > 5000 { + for k, t := range s.seen { + if now.Sub(t) > dedupTTL { + delete(s.seen, k) + } + } + } + if t, ok := s.seen[key]; ok && now.Sub(t) < dedupTTL { + return false + } + s.seen[key] = now + return true +} + +func (s *BitrixSync) forget(key string) { + s.mu.Lock() + delete(s.seen, key) + s.mu.Unlock() +} + +func (s *BitrixSync) worker() { + for job := range s.queue { + s.handle(job) + time.Sleep(bitrixPause) + } +} + +func (s *BitrixSync) handle(job *syncJob) { + ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second) + defer cancel() + + job.Attempts++ + err := s.process(ctx, job) + + switch { + case err == nil: + logrus.Infof("bitrix: %s delivered to contact %d (number %s, attempt %d)", + job.Kind, job.ContactID, maskPhone(job.Number), job.Attempts) + + case isPermanent(err): + // ключ остаётся в дедупликации: тот же звонок/SMS повторно не обрабатываем + logrus.Warnf("bitrix: %s skipped (number %s): %v", job.Kind, maskPhone(job.Number), err) + + case job.Attempts >= maxAttempts: + logrus.Errorf("bitrix: %s given up after %d attempts (number %s): %v", + job.Kind, job.Attempts, maskPhone(job.Number), err) + s.forget(job.Key) + + default: + idx := job.Attempts - 1 + if idx >= len(retryDelays) { + idx = len(retryDelays) - 1 + } + delay := retryDelays[idx] + logrus.Warnf("bitrix: %s failed (number %s, attempt %d), retry in %s: %v", + job.Kind, maskPhone(job.Number), job.Attempts, delay, err) + time.AfterFunc(delay, func() { + select { + case s.queue <- job: + default: + logrus.Errorf("bitrix: queue is full, retry lost for %s %s", job.Kind, job.Key) + s.forget(job.Key) + } + }) + } +} + +func (s *BitrixSync) process(ctx context.Context, job *syncJob) error { + if job.ContactID == 0 { + id, err := s.bx.FindContact(ctx, job.Number) + if err != nil { + return err + } + job.ContactID = id + } + if err := s.prepareRecording(ctx, job); err != nil { + return err + } + + comment := job.Comment + switch { + case job.fileB64 != "": + comment += "\n🎧 Запись разговора — во вложении" + case job.linkFallback: + comment += fmt.Sprintf("\n[url=%s]Запись разговора[/url]", job.RecordingURL) + } + return s.bx.AddComment(ctx, job.ContactID, comment, job.fileName, job.fileB64) +} + +// prepareRecording скачивает запись один раз и держит её в задании на время повторов. +// Если скачать не удалось за 3 попытки (или файл слишком большой), в комментарий +// вставляется ссылка, чтобы звонок не потерялся. +func (s *BitrixSync) prepareRecording(ctx context.Context, job *syncJob) error { + if job.RecordingURL == "" || job.fileB64 != "" || job.linkFallback { + return nil + } + data, name, err := s.bx.DownloadRecording(ctx, job.RecordingURL, job.FileBase) + switch { + case err == nil: + job.fileName = name + job.fileB64 = base64.StdEncoding.EncodeToString(data) + return nil + case errors.Is(err, errRecordingTooBig): + logrus.Warnf("bitrix: recording too big, posting link instead (number %s)", maskPhone(job.Number)) + job.linkFallback = true + return nil + case job.Attempts >= 3: + logrus.Warnf("bitrix: recording unavailable (number %s): %v; posting link instead", maskPhone(job.Number), err) + job.linkFallback = true + return nil + default: + return err + } +} diff --git a/service/rest_telephony_service/handlers/telephony/routes.go b/service/rest_telephony_service/handlers/telephony/routes.go index 0941e87..a064579 100644 --- a/service/rest_telephony_service/handlers/telephony/routes.go +++ b/service/rest_telephony_service/handlers/telephony/routes.go @@ -1,28 +1,86 @@ package telephonyservice import ( - "github.com/go-chi/chi/v5" + "crypto/subtle" "net/http" + "os" "rest_telephony_service/handlers" typesm "rest_telephony_service/types" + "time" + + "github.com/go-chi/chi/v5" + "github.com/sirupsen/logrus" ) type TelephonyReg struct { - ipc *typesm.InternalProviderControl + ipc *typesm.InternalProviderControl + sync *BitrixSync + loc *time.Location + debugRaw bool } -// RegisterTelephonyRoutes регистрирует маршруты телефонии +// tokenAuth проверяет ?token=... (у вебхуков «Мои Звонки» нет подписи). +func tokenAuth(token string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got := r.URL.Query().Get("token") + if subtle.ConstantTimeCompare([]byte(got), []byte(token)) != 1 { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusUnauthorized) + _, _ = w.Write([]byte(`{"error_code":401,"error_description":"unauthorized"}`)) + return + } + next.ServeHTTP(w, r) + }) + } +} + +// RegisterTelephonyRoutes регистрирует маршруты телефонии. +// +// Переменные окружения: +// +// BITRIX_WEBHOOK_URL необязательна: переопределяет константу bitrixWebhookURL из bitrix.go +// TELEPHONY_WEBHOOK_TOKEN секрет в URL вебхука (?token=...); если пусто — проверка отключена +// TELEPHONY_TZ часовой пояс для времени в комментариях (по умолчанию Europe/Moscow) +// TELEPHONY_DEBUG_RAW "1" — логировать сырые тела вебхуков (содержат номера и тексты) func RegisterTelephonyRoutes(r chi.Router, ipc *typesm.InternalProviderControl) error { + bxURL := os.Getenv("BITRIX_WEBHOOK_URL") + if bxURL == "" { + bxURL = bitrixWebhookURL + } + + tzName := os.Getenv("TELEPHONY_TZ") + if tzName == "" { + tzName = "Europe/Moscow" + } + loc, err := time.LoadLocation(tzName) + if err != nil { + logrus.Warnf("cannot load timezone %q (%v), using UTC+3", tzName, err) + loc = time.FixedZone("MSK", 3*60*60) + } + + token := os.Getenv("TELEPHONY_WEBHOOK_TOKEN") + if token == "" { + logrus.Warn("⚠️ TELEPHONY_WEBHOOK_TOKEN is empty: webhook is open to anyone. Getting default token from constants") + token = "795ea01b3b195296ec53e35342deed0aa418b7630ce8ed31" + } + s := &TelephonyReg{ - ipc: ipc, + ipc: ipc, + sync: NewBitrixSync(NewBitrixClient(bxURL)), + loc: loc, + debugRaw: os.Getenv("TELEPHONY_DEBUG_RAW") == "1", } r.Route("/api/v1/telephony", func(r chi.Router) { - // Вебхук открыт для провайдера - handlers.RegisterRoute(r, http.MethodPost, "/webhook", s.WebhookTelephonyHandler) + webhook := r + if token != "" { + webhook = r.With(tokenAuth(token)) + } + handlers.RegisterRoute(webhook, http.MethodPost, "/webhook", s.WebhookTelephonyHandler) - // Отдача данных. Если скрипту Google нужен доступ, - // здесь можно добавить r.Use(handlers.AccessCodeVerifier(ipc.Config)) + // Отдача данных для Google Script. При необходимости закройте + // r.Use(handlers.AccessCodeVerifier(ipc.Config)). handlers.RegisterRoute(r, http.MethodGet, "/sms-report", s.GetSmsReportHandler) }) diff --git a/service/rest_telephony_service/handlers/telephony/type.go b/service/rest_telephony_service/handlers/telephony/type.go new file mode 100644 index 0000000..c790a16 --- /dev/null +++ b/service/rest_telephony_service/handlers/telephony/type.go @@ -0,0 +1,93 @@ +package telephonyservice + +import ( + "encoding/json" + "strconv" + "strings" +) + +// FlexString принимает и JSON-строку, и число (src_id, db_call_id и т.п.). +type FlexString string + +func (f *FlexString) UnmarshalJSON(b []byte) error { + s := strings.TrimSpace(string(b)) + if s == "null" { + return nil + } + if len(s) > 0 && s[0] == '"' { + var v string + if err := json.Unmarshal(b, &v); err != nil { + return err + } + *f = FlexString(v) + return nil + } + *f = FlexString(s) + return nil +} + +func (f FlexString) String() string { return string(f) } + +// FlexInt принимает число, число в строке, true/false и null. +type FlexInt int64 + +func (f *FlexInt) UnmarshalJSON(b []byte) error { + s := strings.Trim(strings.TrimSpace(string(b)), `"`) + switch s { + case "", "null", "false": + *f = 0 + return nil + case "true": + *f = 1 + return nil + } + if n, err := strconv.ParseInt(s, 10, 64); err == nil { + *f = FlexInt(n) + return nil + } + fl, err := strconv.ParseFloat(s, 64) + if err != nil { + return err + } + *f = FlexInt(int64(fl)) + return nil +} + +// webhookReq — корневой объект POST-запроса от «Мои Звонки». +type webhookReq struct { + Webhook webhookMeta `json:"webhook"` + Event callEvent `json:"event"` +} + +type webhookMeta struct { + Action string `json:"action"` + AccountID FlexString `json:"account_id"` + AccountName string `json:"account_name"` + UserID FlexString `json:"user_id"` + UserLogin string `json:"user_login"` +} + +// callEvent — событие звонка (тип 1, 2, 4) или SMS (тип 32). +type callEvent struct { + EventType FlexInt `json:"event_type"` // 1 начало, 2 ответ, 4 окончание, 32 SMS + EventCreated FlexInt `json:"event_created"` + Direction FlexInt `json:"direction"` // 0 входящий, 1 исходящий + ClientNumber FlexString `json:"client_number"` + ClientName string `json:"client_name"` + EventPbxCallID FlexString `json:"event_pbx_call_id"` + SrcNumber FlexString `json:"src_number"` + SrcID FlexString `json:"src_id"` + SrcSlot FlexInt `json:"src_slot"` + + // Только call.finish + StartTime FlexInt `json:"start_time"` + AnswerTime FlexInt `json:"answer_time"` + EndTime FlexInt `json:"end_time"` + Duration FlexInt `json:"duration"` + Answered FlexInt `json:"answered"` + Recording string `json:"recording"` + DBCallID FlexString `json:"db_call_id"` + + // Только sms.message + Text string `json:"text"` +}