Update telephony service: Added calls webhook handler #203
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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"`
|
||||
}
|
||||
Loading…
Reference in New Issue