Update telephony service: Added calls webhook handler #203

Merged
romanskijdev merged 1 commits from fix-permissions into main 2026-10-24 20:57:49 +03:00
5 changed files with 782 additions and 104 deletions

View File

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

View File

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

View File

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

View File

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

View File

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