680 lines
25 KiB
Go
680 lines
25 KiB
Go
package api
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"log/slog"
|
||
"net/http"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
"unicode/utf8"
|
||
|
||
"dana/internal/domain"
|
||
"dana/internal/onec"
|
||
"dana/internal/storage"
|
||
)
|
||
|
||
// Расписание врачей и запись на приём из 1С: окна забираются по таймеру и хранятся у нас,
|
||
// перед записью окно перепроверяется в 1С. Если 1С не отвечает, сайт не падает, а принимает обычную заявку.
|
||
|
||
const (
|
||
onecHorizonDays = 14
|
||
onecSyncEvery = 5 * time.Minute
|
||
onecDirEvery = time.Hour
|
||
onecStaleAfter = 24 * time.Hour // после этого срока без удачной синхронизации окна не показываем
|
||
onecSourceLabel = "Сайт"
|
||
maxAppointmentIn = 16 << 10
|
||
)
|
||
|
||
// WithOneC подключает 1С; без адреса или ключа запись через 1С выключена.
|
||
func (a *API) WithOneC(c *onec.Client) { a.onec = c }
|
||
|
||
// WithOneCTuning задаёт период опроса (0 — по умолчанию) и включает long polling через GET /changes.
|
||
func (a *API) WithOneCTuning(every time.Duration, longPoll bool) {
|
||
a.onecEvery, a.onecLongPoll = every, longPoll
|
||
}
|
||
|
||
var onecSyncMu sync.Mutex // одна синхронизация за раз: фоновая и ручная не пересекаются
|
||
|
||
func onecWindow() (from, to time.Time) {
|
||
now := time.Now().In(moscow)
|
||
from = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, moscow)
|
||
return from, from.AddDate(0, 0, onecHorizonDays)
|
||
}
|
||
|
||
// syncOneC забирает расписание на 14 дней; справочники (филиалы, врачи, услуги) — при dir=true.
|
||
func (a *API) syncOneC(ctx context.Context, dir bool) (err error) {
|
||
if !a.onec.Configured() {
|
||
return errors.New("1С не подключена: задайте ONEC_API_URL и ONEC_API_KEY")
|
||
}
|
||
onecSyncMu.Lock()
|
||
defer onecSyncMu.Unlock()
|
||
logID, err := a.store.StartOnecSync(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
doctors, slotsN := 0, 0
|
||
defer func() {
|
||
errText := ""
|
||
if err != nil {
|
||
errText = onecErrText(err)
|
||
}
|
||
if e := a.store.FinishOnecSync(context.Background(), logID, doctors, slotsN, errText); e != nil {
|
||
slog.Warn("onec sync log", "err", e)
|
||
}
|
||
}()
|
||
|
||
if dir {
|
||
branches, err := a.onec.Branches(ctx)
|
||
if err != nil {
|
||
return fmt.Errorf("филиалы: %w", err)
|
||
}
|
||
docs, err := a.onec.Doctors(ctx)
|
||
if err != nil {
|
||
return fmt.Errorf("врачи: %w", err)
|
||
}
|
||
linked, err := a.store.SaveOnecDirectory(ctx, branches, docs)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
doctors = len(docs)
|
||
if linked > 0 {
|
||
slog.Info("onec: врачи привязаны по ФИО", "count", linked)
|
||
}
|
||
ids, err := a.store.LinkedOnecDoctorIDs(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
for _, id := range ids {
|
||
svc, err := a.onec.Services(ctx, id)
|
||
if err != nil {
|
||
slog.Warn("onec: услуги врача", "doctor", id, "err", err)
|
||
continue
|
||
}
|
||
if err := a.store.SaveOnecServices(ctx, id, svc); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
|
||
from, to := onecWindow()
|
||
slots, err := a.onec.Schedule(ctx, from, to, "")
|
||
if err != nil {
|
||
return fmt.Errorf("расписание: %w", err)
|
||
}
|
||
slotsN = len(slots)
|
||
return a.store.ReplaceOnecSlots(ctx, from, to, slots)
|
||
}
|
||
|
||
func onecErrText(err error) string {
|
||
if errors.Is(err, onec.ErrUnauthorized) {
|
||
return "1С не приняла ключ доступа: проверьте ONEC_API_KEY и что IP сервера сайта открыт в 1С. " + err.Error()
|
||
}
|
||
return err.Error()
|
||
}
|
||
|
||
// RunOneCSync — фоновая синхронизация: при старте и каждые 5 минут; справочники — раз в час.
|
||
func (a *API) RunOneCSync(ctx context.Context) {
|
||
if !a.onec.Configured() {
|
||
return
|
||
}
|
||
slog.Info("onec sync enabled", "host", a.onec.Host())
|
||
lastDir := time.Time{}
|
||
run := func() {
|
||
dir := time.Since(lastDir) >= onecDirEvery
|
||
c, cancel := context.WithTimeout(ctx, 2*time.Minute)
|
||
defer cancel()
|
||
if err := a.syncOneC(c, dir); err != nil {
|
||
slog.Warn("onec sync", "err", err)
|
||
return
|
||
}
|
||
if dir {
|
||
lastDir = time.Now()
|
||
}
|
||
}
|
||
run()
|
||
every := a.onecEvery
|
||
if every <= 0 {
|
||
every = onecSyncEvery
|
||
}
|
||
if a.onecLongPoll {
|
||
go a.runOneCLongPoll(ctx)
|
||
}
|
||
t := time.NewTicker(every)
|
||
defer t.Stop()
|
||
for {
|
||
select {
|
||
case <-ctx.Done():
|
||
return
|
||
case <-t.C:
|
||
run()
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------- Публичное API ----------
|
||
|
||
// doctorSlots отдаёт свободные окна врача и услуги приёма. enabled=false — запись через 1С недоступна,
|
||
// и фронт остаётся на обычной заявке (у врача не включена запись, 1С не подключена или давно не отвечала).
|
||
func (a *API) doctorSlots(w http.ResponseWriter, r *http.Request) {
|
||
w.Header().Set("Cache-Control", "no-store")
|
||
off := func() { ok(w, map[string]any{"enabled": false, "slots": []any{}, "services": []any{}}, nil) }
|
||
if !a.onec.Configured() {
|
||
off()
|
||
return
|
||
}
|
||
onecID, _, err := a.store.OnecDoctorBySlug(r.Context(), r.PathValue("slug"))
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
if onecID == "" || !a.store.OnecFresh(r.Context(), onecStaleAfter) {
|
||
off()
|
||
return
|
||
}
|
||
from, to := onecWindow()
|
||
slots, err := a.store.FreeOnecSlots(r.Context(), onecID, from, to)
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
services, err := a.store.OnecServices(r.Context(), onecID)
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
ok(w, map[string]any{"enabled": true, "slots": slots, "services": services}, map[string]any{"total": len(slots)})
|
||
}
|
||
|
||
type appointmentInput struct {
|
||
DoctorSlug string `json:"doctor_slug"`
|
||
Start string `json:"start"`
|
||
BranchID string `json:"branch_id"`
|
||
ServiceID string `json:"service_id"`
|
||
Name string `json:"name"`
|
||
Phone string `json:"phone"`
|
||
VerificationID string `json:"verification_id"`
|
||
BirthDate string `json:"birth_date"`
|
||
Comment string `json:"comment"`
|
||
Consent bool `json:"consent"`
|
||
RequestID string `json:"request_id"`
|
||
PageURL string `json:"page_url"`
|
||
UTM map[string]string `json:"utm"`
|
||
}
|
||
|
||
var (
|
||
requestIDRE = regexp.MustCompile(`^[A-Za-z0-9_-]{8,64}$`)
|
||
birthDateRE = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}$`)
|
||
)
|
||
|
||
// createAppointment записывает пациента в 1С и заводит заявку в «Заявках». Сбой 1С (кроме «окно занято»)
|
||
// не теряет обращение: заявка сохраняется обычной, администратор перезвонит.
|
||
func (a *API) createAppointment(w http.ResponseWriter, r *http.Request) {
|
||
if a.tooMany(w, "appt:"+clientIP(r), 10, 10*time.Minute) {
|
||
return
|
||
}
|
||
var in appointmentInput
|
||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxAppointmentIn)).Decode(&in); err != nil {
|
||
fail(w, http.StatusBadRequest, "bad_json", "Не удалось разобрать запрос")
|
||
return
|
||
}
|
||
in.Name = strings.TrimSpace(in.Name)
|
||
in.Phone = strings.TrimSpace(in.Phone)
|
||
in.Comment = strings.TrimSpace(in.Comment)
|
||
for _, v := range []string{in.Name, in.Phone, in.Comment} {
|
||
if strings.ContainsRune(v, utf8.RuneError) {
|
||
fail(w, http.StatusBadRequest, "bad_encoding", "Текст пришёл в неверной кодировке — отправьте форму ещё раз")
|
||
return
|
||
}
|
||
}
|
||
if !in.Consent {
|
||
fail(w, http.StatusBadRequest, "consent_required", "Нужно согласие на обработку персональных данных")
|
||
return
|
||
}
|
||
if in.Name == "" {
|
||
fail(w, http.StatusBadRequest, "name_required", "Укажите имя")
|
||
return
|
||
}
|
||
if len(digitsRE.ReplaceAllString(in.Phone, "")) < 10 {
|
||
fail(w, http.StatusBadRequest, "phone_invalid", "Укажите корректный телефон")
|
||
return
|
||
}
|
||
|
||
if !requestIDRE.MatchString(in.RequestID) {
|
||
fail(w, http.StatusBadRequest, "request_id_invalid", "Не удалось отправить запись, обновите страницу")
|
||
return
|
||
}
|
||
if in.BirthDate != "" && !birthDateRE.MatchString(in.BirthDate) {
|
||
fail(w, http.StatusBadRequest, "birth_invalid", "Дата рождения указана неверно")
|
||
return
|
||
}
|
||
start, err := time.Parse(time.RFC3339, in.Start)
|
||
if err != nil || start.Before(time.Now()) || start.After(time.Now().AddDate(0, 0, onecHorizonDays+2)) {
|
||
fail(w, http.StatusBadRequest, "start_invalid", "Выберите время приёма ещё раз")
|
||
return
|
||
}
|
||
if !a.onec.Configured() {
|
||
fail(w, http.StatusServiceUnavailable, "onec_disabled", "Онлайн-запись сейчас недоступна, оставьте заявку")
|
||
return
|
||
}
|
||
ctx := r.Context()
|
||
onecID, doctorID, err := a.store.OnecDoctorBySlug(ctx, in.DoctorSlug)
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
if onecID == "" {
|
||
fail(w, http.StatusNotFound, "doctor_not_bookable", "К этому врачу онлайн-запись недоступна, оставьте заявку")
|
||
return
|
||
}
|
||
|
||
// Защита расписания от ботов. Обычно запись идёт без звонка, а при подозрительной активности
|
||
// (всплеск записей, много неподтверждённых к врачу, много записей на номер) сайт просит
|
||
// проверочный звонок: настоящий пациент записывается дальше, бот останавливается.
|
||
// Без SMSC подозрительная запись не занимает окно, а уходит оператору заявкой.
|
||
cfg, err := a.store.BookingSettings(ctx)
|
||
if err != nil {
|
||
slog.Warn("booking settings", "err", err)
|
||
cfg = storage.DefaultBookingSettings
|
||
}
|
||
risk, err := a.bookingRiskReason(ctx, cfg, onecID, in.Phone, start)
|
||
if err != nil {
|
||
slog.Warn("booking limits", "err", err)
|
||
}
|
||
leadOnly := ""
|
||
if cfg.PhoneCheck || risk != "" {
|
||
if a.smscLogin != "" {
|
||
if in.VerificationID == "" || !wcm.isVerified(in.VerificationID, in.Phone) {
|
||
if risk != "" {
|
||
slog.Warn("booking: прошу проверочный звонок", "reason", risk)
|
||
}
|
||
fail(w, http.StatusForbidden, "phone_not_verified", "Подтвердите номер телефона с помощью проверочного звонка")
|
||
return
|
||
}
|
||
} else if risk != "" {
|
||
leadOnly = risk
|
||
}
|
||
}
|
||
// не больше 3 записей в час на один номер: проверяем после звонка, чтобы отклонённая попытка
|
||
// без звонка не тратила пациенту лимит
|
||
if a.tooMany(w, "appt-phone:"+lastDigits(in.Phone, 10), 3, time.Hour) {
|
||
return
|
||
}
|
||
|
||
rec, created, err := a.store.BeginOnecAppointment(ctx, storage.OnecAppointment{
|
||
RequestID: in.RequestID, DoctorOnec: onecID, BranchID: in.BranchID, ServiceID: in.ServiceID,
|
||
Start: start, Patient: in.Name, Phone: in.Phone,
|
||
})
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
if !created {
|
||
a.repeatAppointment(w, rec)
|
||
return
|
||
}
|
||
|
||
if leadOnly != "" {
|
||
slog.Warn("booking: SMSC не настроен, подозрительная запись станет заявкой", "reason", leadOnly)
|
||
a.appointmentFallback(w, r, in, doctorID, rec, fmt.Errorf("%w: %s", errBookingLimit, leadOnly))
|
||
return
|
||
}
|
||
|
||
var slot *onec.Slot
|
||
var end time.Time
|
||
var apptID string
|
||
|
||
if a.onec.Configured() {
|
||
// Окно ещё свободно? Спрашиваем 1С по этому врачу на этот день.
|
||
dayFrom := time.Date(start.In(moscow).Year(), start.In(moscow).Month(), start.In(moscow).Day(), 0, 0, 0, 0, moscow)
|
||
dayTo := dayFrom.AddDate(0, 0, 1)
|
||
fresh, err := a.onec.Schedule(ctx, dayFrom, dayTo, onecID)
|
||
if err != nil {
|
||
a.appointmentFallback(w, r, in, doctorID, rec, err)
|
||
return
|
||
}
|
||
_ = a.store.ReplaceOnecDoctorSlots(ctx, onecID, dayFrom, dayTo, fresh)
|
||
for i := range fresh {
|
||
s := fresh[i]
|
||
if s.Free() && s.Start.Equal(start) && (in.BranchID == "" || s.BranchID == in.BranchID) {
|
||
slot = &s
|
||
break
|
||
}
|
||
}
|
||
if slot == nil {
|
||
a.slotTaken(w, r, rec, onecID, "окно уже занято")
|
||
return
|
||
}
|
||
|
||
appt, err := a.onec.Book(ctx, onec.AppointmentRequest{
|
||
RequestID: in.RequestID, DoctorID: onecID, BranchID: slot.BranchID, ServiceID: in.ServiceID, SlotID: slot.SlotID,
|
||
Start: slot.Start, Name: in.Name, Phone: in.Phone, BirthDate: in.BirthDate, Comment: in.Comment, Source: onecSourceLabel,
|
||
})
|
||
switch {
|
||
case errors.Is(err, onec.ErrSlotBusy):
|
||
_ = a.store.MarkOnecSlotBusy(ctx, onecID, slot.BranchID, slot.Start)
|
||
a.slotTaken(w, r, rec, onecID, err.Error())
|
||
return
|
||
case err != nil:
|
||
a.appointmentFallback(w, r, in, doctorID, rec, err)
|
||
return
|
||
}
|
||
_ = a.store.MarkOnecSlotBusy(ctx, onecID, slot.BranchID, slot.Start)
|
||
|
||
end = appt.End
|
||
if end.IsZero() {
|
||
end = slot.End
|
||
}
|
||
apptID = appt.ID
|
||
} else {
|
||
// Режим Push/Pull (1С сама опрашивает очередь по регламентному заданию)
|
||
localSlots, err := a.store.FreeOnecSlots(ctx, onecID, start, start.Add(time.Minute))
|
||
if err != nil || len(localSlots) == 0 {
|
||
a.slotTaken(w, r, rec, onecID, "окно уже занято")
|
||
return
|
||
}
|
||
for i := range localSlots {
|
||
ls := localSlots[i]
|
||
if in.BranchID == "" || ls.BranchID == in.BranchID {
|
||
slot = &onec.Slot{
|
||
DoctorID: onecID,
|
||
BranchID: ls.BranchID,
|
||
Start: ls.Start,
|
||
End: ls.End,
|
||
Status: "free",
|
||
}
|
||
break
|
||
}
|
||
}
|
||
if slot == nil {
|
||
a.slotTaken(w, r, rec, onecID, "окно уже занято")
|
||
return
|
||
}
|
||
_ = a.store.MarkOnecSlotBusy(ctx, onecID, slot.BranchID, slot.Start)
|
||
end = slot.End
|
||
}
|
||
|
||
branch := a.store.OnecBranchName(ctx, slot.BranchID)
|
||
confirm := a.bookingConfirmEnabled()
|
||
note := "Запись подтверждена в 1С"
|
||
if confirm {
|
||
note = "Запись сделана в 1С, ждёт подтверждения оператором в Битрикс24"
|
||
}
|
||
leadID := a.saveAppointmentLead(ctx, r, in, doctorID, fmt.Sprintf("%s: %s, %s.%s",
|
||
note, formatSlotTime(slot.Start), branchOrDash(branch), a.serviceNote(ctx, onecID, in.ServiceID)), map[string]any{
|
||
"onec_appointment_id": apptID, "onec_doctor_id": onecID, "slot_start": slot.Start.Format(time.RFC3339),
|
||
})
|
||
if apptID != "" {
|
||
if err := a.store.FinishOnecAppointment(context.Background(), rec.ID, "booked", apptID, "", &end, leadID); err != nil {
|
||
slog.Error("onec appointment finish", "id", rec.ID, "err", err)
|
||
}
|
||
if confirm {
|
||
if err := a.store.StartBookingConfirm(context.Background(), rec.ID); err != nil {
|
||
slog.Error("booking confirm start", "id", rec.ID, "err", err)
|
||
}
|
||
a.kickConfirm()
|
||
}
|
||
}
|
||
wcm.consume(in.VerificationID)
|
||
writeJSON(w, http.StatusCreated, envelope{Data: map[string]any{
|
||
"mode": "booked",
|
||
"start": slot.Start,
|
||
"end": end,
|
||
"branch": branch,
|
||
"message": a.bookedMessage(slot.Start),
|
||
}})
|
||
}
|
||
|
||
// bookedMessage — что видит пациент после записи. При подтверждении оператором честно говорим, что позвонят.
|
||
func (a *API) bookedMessage(start time.Time) string {
|
||
if a.bookingConfirmEnabled() {
|
||
return "Вы записаны на приём " + formatSlotTime(start) + ". Администратор позвонит вам, чтобы подтвердить запись."
|
||
}
|
||
return "Вы записаны на приём " + formatSlotTime(start) + ". Ждём вас в клинике!"
|
||
}
|
||
|
||
// repeatAppointment отвечает на повтор того же запроса (тот же request_id), не создавая записи заново.
|
||
func (a *API) repeatAppointment(w http.ResponseWriter, rec storage.OnecAppointment) {
|
||
switch rec.Status {
|
||
case "booked":
|
||
writeJSON(w, http.StatusOK, envelope{Data: map[string]any{
|
||
"mode": "booked", "start": rec.Start, "message": a.bookedMessage(rec.Start),
|
||
}})
|
||
case "failed":
|
||
writeJSON(w, http.StatusOK, envelope{Data: map[string]any{
|
||
"mode": "lead", "message": "Спасибо! Мы получили заявку и перезвоним, чтобы подтвердить запись.",
|
||
}})
|
||
default:
|
||
fail(w, http.StatusConflict, "in_progress", "Запись уже оформляется, подождите несколько секунд")
|
||
}
|
||
}
|
||
|
||
// slotTaken — окно заняли: отдаём 409 и свежий список окон, чтобы пациент выбрал другое.
|
||
func (a *API) slotTaken(w http.ResponseWriter, r *http.Request, rec storage.OnecAppointment, onecID, reason string) {
|
||
_ = a.store.FinishOnecAppointment(context.Background(), rec.ID, "failed", "", "slot_busy: "+reason, nil, nil)
|
||
from, to := onecWindow()
|
||
slots, _ := a.store.FreeOnecSlots(r.Context(), onecID, from, to)
|
||
if slots == nil {
|
||
slots = []storage.OnecSlot{}
|
||
}
|
||
writeJSON(w, http.StatusConflict, map[string]any{
|
||
"error": map[string]any{"code": "slot_busy", "message": "Это время только что заняли. Выберите другое."},
|
||
"slots": slots,
|
||
})
|
||
}
|
||
|
||
// appointmentFallback — 1С не смогла принять запись: сохраняем обычную заявку и честно говорим об этом администратору.
|
||
func (a *API) appointmentFallback(w http.ResponseWriter, r *http.Request, in appointmentInput, doctorID int64, rec storage.OnecAppointment, cause error) {
|
||
slog.Warn("onec: запись не прошла, сохраняем заявку", "request_id", rec.RequestID, "err", cause)
|
||
start, _ := time.Parse(time.RFC3339, in.Start)
|
||
msg := fmt.Sprintf("НЕ ЗАПИСАН В 1С (%s). Пациент выбрал: %s. Перезвоните и запишите вручную.%s",
|
||
onecErrText(cause), formatSlotTime(start), a.serviceNote(r.Context(), rec.DoctorOnec, in.ServiceID))
|
||
leadID := a.saveAppointmentLead(r.Context(), r, in, doctorID, msg, map[string]any{"onec_error": cause.Error()})
|
||
_ = a.store.FinishOnecAppointment(context.Background(), rec.ID, "failed", "", cause.Error(), nil, leadID)
|
||
// оператор работает в Битрикс24 — передаём заявку туда, чтобы записать пациента вручную
|
||
if a.bookingConfirmEnabled() {
|
||
if err := a.store.MarkLeadOnly(context.Background(), rec.ID); err != nil {
|
||
slog.Error("booking lead-only mark", "id", rec.ID, "err", err)
|
||
}
|
||
a.kickConfirm()
|
||
}
|
||
writeJSON(w, http.StatusCreated, envelope{Data: map[string]any{
|
||
"mode": "lead", "message": "Спасибо! Мы получили заявку и перезвоним, чтобы подтвердить запись.",
|
||
}})
|
||
}
|
||
|
||
func (a *API) saveAppointmentLead(ctx context.Context, r *http.Request, in appointmentInput, doctorID int64, message string, extra map[string]any) *int64 {
|
||
var formID *int64
|
||
if f, err := a.store.FormByCode(ctx, "appointment"); err == nil {
|
||
formID = &f.ID
|
||
}
|
||
if in.Comment != "" {
|
||
message += "\nКомментарий пациента: " + in.Comment
|
||
}
|
||
if in.BirthDate != "" {
|
||
extra["birth_date"] = in.BirthDate
|
||
}
|
||
id, err := a.store.CreateLead(ctx, formID, domain.LeadInput{
|
||
Name: in.Name, Phone: in.Phone, DoctorID: &doctorID, Message: message, Extra: extra,
|
||
PageURL: in.PageURL, UTM: cleanUTM(in.UTM), Consent: true,
|
||
}, clientIP(r), r.UserAgent())
|
||
if err != nil {
|
||
slog.Error("onec: заявка не сохранилась", "err", err)
|
||
return nil
|
||
}
|
||
a.notifyLead(id)
|
||
return &id
|
||
}
|
||
|
||
func (a *API) serviceNote(ctx context.Context, onecID, serviceID string) string {
|
||
if serviceID == "" {
|
||
return ""
|
||
}
|
||
if n := a.store.OnecServiceName(ctx, onecID, serviceID); n != "" {
|
||
return " Услуга: " + n + "."
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func formatSlotTime(t time.Time) string {
|
||
return t.In(moscow).Format("02.01.2006 в 15:04")
|
||
}
|
||
|
||
func branchOrDash(s string) string {
|
||
if s == "" {
|
||
return "филиал не указан"
|
||
}
|
||
return s
|
||
}
|
||
|
||
// ---------- Админка ----------
|
||
|
||
func (a *API) adminOnec(w http.ResponseWriter, r *http.Request, u *storage.AdminUser) {
|
||
st, err := a.store.OnecSyncStatus(r.Context())
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
doctors, err := a.store.OnecDoctorsAdmin(r.Context())
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
ok(w, map[string]any{
|
||
"configured": a.onec.Configured(),
|
||
"host": a.onec.Host(),
|
||
"status": st,
|
||
"doctors": doctors,
|
||
}, nil)
|
||
}
|
||
|
||
func (a *API) adminOnecSync(w http.ResponseWriter, r *http.Request, u *storage.AdminUser) {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Minute)
|
||
defer cancel()
|
||
if err := a.syncOneC(ctx, true); err != nil {
|
||
fail(w, http.StatusBadGateway, "onec_sync", onecErrText(err))
|
||
return
|
||
}
|
||
a.adminOnec(w, r, u)
|
||
}
|
||
|
||
func (a *API) adminOnecLink(w http.ResponseWriter, r *http.Request, u *storage.AdminUser) {
|
||
var in struct {
|
||
DoctorID *int64 `json:"doctor_id"`
|
||
}
|
||
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
|
||
fail(w, http.StatusBadRequest, "bad_request", "Некорректный запрос")
|
||
return
|
||
}
|
||
if err := a.store.SetOnecDoctorLink(r.Context(), r.PathValue("onec_id"), in.DoctorID); err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
var id int64
|
||
if in.DoctorID != nil {
|
||
id = *in.DoctorID
|
||
}
|
||
a.store.Audit(r.Context(), u.ID, "link", "onec_doctor", id, clientIP(r))
|
||
ok(w, map[string]any{"onec_id": r.PathValue("onec_id"), "doctor_id": in.DoctorID}, nil)
|
||
}
|
||
|
||
func (a *API) adminOnecBooking(w http.ResponseWriter, r *http.Request, u *storage.AdminUser) {
|
||
var in struct {
|
||
Enabled bool `json:"enabled"`
|
||
}
|
||
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
|
||
fail(w, http.StatusBadRequest, "bad_request", "Некорректный запрос")
|
||
return
|
||
}
|
||
if err := a.store.SetOnecBooking(r.Context(), r.PathValue("onec_id"), in.Enabled); err != nil {
|
||
if errors.Is(err, storage.ErrNotFound) {
|
||
fail(w, http.StatusUnprocessableEntity, "not_linked", "Сначала привяжите врача к карточке сайта")
|
||
return
|
||
}
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
a.store.Audit(r.Context(), u.ID, "booking", "onec_doctor", 0, clientIP(r))
|
||
ok(w, map[string]any{"onec_id": r.PathValue("onec_id"), "enabled": in.Enabled}, nil)
|
||
}
|
||
|
||
func (a *API) adminOnecGrid(w http.ResponseWriter, r *http.Request, u *storage.AdminUser) {
|
||
day := time.Now().In(moscow)
|
||
if s := r.URL.Query().Get("date"); s != "" {
|
||
d, err := time.ParseInLocation("2006-01-02", s, moscow)
|
||
if err != nil {
|
||
fail(w, http.StatusBadRequest, "bad_date", "Дата указана неверно")
|
||
return
|
||
}
|
||
day = d
|
||
}
|
||
day = time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, moscow)
|
||
rows, err := a.store.OnecGrid(r.Context(), day)
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
ok(w, rows, map[string]any{"date": day.Format("2006-01-02")})
|
||
}
|
||
|
||
func (a *API) adminOnecAppointments(w http.ResponseWriter, r *http.Request, u *storage.AdminUser) {
|
||
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
|
||
if limit <= 0 || limit > 500 {
|
||
limit = 100
|
||
}
|
||
list, err := a.store.OnecAppointments(r.Context(), limit)
|
||
if err != nil {
|
||
handleErr(w, err)
|
||
return
|
||
}
|
||
// в списке — имена и телефоны пациентов: просмотр фиксируем в аудите
|
||
a.store.Audit(r.Context(), u.ID, "view", "onec_appointments", 0, clientIP(r))
|
||
ok(w, list, map[string]any{"total": len(list)})
|
||
}
|
||
|
||
// runOneCLongPoll держит у 1С запрос /changes: как только версия расписания выросла, окна перечитываются сразу.
|
||
func (a *API) runOneCLongPoll(ctx context.Context) {
|
||
slog.Info("onec long polling enabled")
|
||
var since int64
|
||
first := true
|
||
for ctx.Err() == nil {
|
||
wait := 25 * time.Second
|
||
if first {
|
||
wait = 0 // первый запрос только узнаёт текущую версию, не ожидая изменений
|
||
}
|
||
version, ids, err := a.onec.Changes(ctx, since, wait)
|
||
if err != nil {
|
||
slog.Warn("onec long poll", "err", err)
|
||
select {
|
||
case <-ctx.Done():
|
||
return
|
||
case <-time.After(5 * time.Second):
|
||
}
|
||
continue
|
||
}
|
||
if first {
|
||
first = false
|
||
since = version // первый ответ только запоминает версию: полный опрос уже сделан при старте
|
||
continue
|
||
}
|
||
if version <= since {
|
||
continue
|
||
}
|
||
since = version
|
||
if len(ids) == 0 {
|
||
a.onecFullResyncAsync(false)
|
||
continue
|
||
}
|
||
for _, id := range ids {
|
||
if err := a.resyncOnecDoctor(ctx, id); err != nil {
|
||
slog.Warn("onec long poll: врач не обновился", "doctor", id, "err", err)
|
||
}
|
||
}
|
||
}
|
||
}
|