Ilia Denisov
626 lines
20 KiB
Go
626 lines
20 KiB
Go
package internalhttp
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"galaxy/mail/internal/domain/attempt"
|
|
"galaxy/mail/internal/domain/common"
|
|
deliverydomain "galaxy/mail/internal/domain/delivery"
|
|
"galaxy/mail/internal/service/listdeliveries"
|
|
)
|
|
|
|
const (
|
|
// ErrorCodeDeliveryNotFound identifies a missing trusted delivery lookup
|
|
// target.
|
|
ErrorCodeDeliveryNotFound = "delivery_not_found"
|
|
|
|
// ErrorCodeResendNotAllowed identifies resend requests against non-terminal
|
|
// deliveries.
|
|
ErrorCodeResendNotAllowed = "resend_not_allowed"
|
|
|
|
deliveryIDPathValue = "delivery_id"
|
|
)
|
|
|
|
// DeliveryListQuery stores the raw trusted query-string values accepted by the
|
|
// operator delivery-list route before normalization.
|
|
type DeliveryListQuery struct {
|
|
// Recipient stores the optional recipient filter covering `to`, `cc`, and
|
|
// `bcc`.
|
|
Recipient string
|
|
|
|
// Status stores the optional delivery-status filter.
|
|
Status string
|
|
|
|
// Source stores the optional delivery-source filter.
|
|
Source string
|
|
|
|
// TemplateID stores the optional template-family filter.
|
|
TemplateID string
|
|
|
|
// IdempotencyKey stores the optional idempotency-key filter.
|
|
IdempotencyKey string
|
|
|
|
// FromCreatedAtMS stores the optional inclusive lower creation-time bound.
|
|
FromCreatedAtMS string
|
|
|
|
// ToCreatedAtMS stores the optional inclusive upper creation-time bound.
|
|
ToCreatedAtMS string
|
|
|
|
// Limit stores the optional page size.
|
|
Limit string
|
|
|
|
// Cursor stores the optional opaque continuation cursor.
|
|
Cursor string
|
|
}
|
|
|
|
// DeliverySummaryResponse stores one brief operator-facing delivery record.
|
|
type DeliverySummaryResponse struct {
|
|
DeliveryID string `json:"delivery_id"`
|
|
ResendParentDeliveryID string `json:"resend_parent_delivery_id,omitempty"`
|
|
Source string `json:"source"`
|
|
PayloadMode string `json:"payload_mode"`
|
|
TemplateID string `json:"template_id,omitempty"`
|
|
To []string `json:"to"`
|
|
Cc []string `json:"cc"`
|
|
Bcc []string `json:"bcc"`
|
|
ReplyTo []string `json:"reply_to"`
|
|
Locale string `json:"locale,omitempty"`
|
|
LocaleFallbackUsed bool `json:"locale_fallback_used"`
|
|
IdempotencyKey string `json:"idempotency_key"`
|
|
Status string `json:"status"`
|
|
AttemptCount int `json:"attempt_count"`
|
|
LastAttemptStatus string `json:"last_attempt_status,omitempty"`
|
|
ProviderSummary string `json:"provider_summary,omitempty"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
UpdatedAtMS int64 `json:"updated_at_ms"`
|
|
SentAtMS *int64 `json:"sent_at_ms,omitempty"`
|
|
SuppressedAtMS *int64 `json:"suppressed_at_ms,omitempty"`
|
|
FailedAtMS *int64 `json:"failed_at_ms,omitempty"`
|
|
DeadLetteredAtMS *int64 `json:"dead_lettered_at_ms,omitempty"`
|
|
}
|
|
|
|
// DeliveryListResponse stores one deterministic page of brief delivery
|
|
// summaries.
|
|
type DeliveryListResponse struct {
|
|
Items []DeliverySummaryResponse `json:"items"`
|
|
NextCursor string `json:"next_cursor,omitempty"`
|
|
}
|
|
|
|
// AttachmentResponse stores one durable attachment audit record.
|
|
type AttachmentResponse struct {
|
|
Filename string `json:"filename"`
|
|
ContentType string `json:"content_type"`
|
|
SizeBytes int64 `json:"size_bytes"`
|
|
}
|
|
|
|
// DeadLetterResponse stores one operator-visible dead-letter entry.
|
|
type DeadLetterResponse struct {
|
|
DeliveryID string `json:"delivery_id"`
|
|
FinalAttemptNo int `json:"final_attempt_no"`
|
|
FailureClassification string `json:"failure_classification"`
|
|
ProviderSummary string `json:"provider_summary,omitempty"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
RecoveryHint string `json:"recovery_hint,omitempty"`
|
|
}
|
|
|
|
// DeliveryDetailResponse stores one full operator-facing delivery view.
|
|
type DeliveryDetailResponse struct {
|
|
DeliveryID string `json:"delivery_id"`
|
|
ResendParentDeliveryID string `json:"resend_parent_delivery_id,omitempty"`
|
|
Source string `json:"source"`
|
|
PayloadMode string `json:"payload_mode"`
|
|
TemplateID string `json:"template_id,omitempty"`
|
|
TemplateVariables map[string]any `json:"template_variables,omitempty"`
|
|
To []string `json:"to"`
|
|
Cc []string `json:"cc"`
|
|
Bcc []string `json:"bcc"`
|
|
ReplyTo []string `json:"reply_to"`
|
|
Subject string `json:"subject,omitempty"`
|
|
TextBody string `json:"text_body,omitempty"`
|
|
HTMLBody string `json:"html_body,omitempty"`
|
|
Attachments []AttachmentResponse `json:"attachments"`
|
|
Locale string `json:"locale,omitempty"`
|
|
LocaleFallbackUsed bool `json:"locale_fallback_used"`
|
|
IdempotencyKey string `json:"idempotency_key"`
|
|
Status string `json:"status"`
|
|
AttemptCount int `json:"attempt_count"`
|
|
LastAttemptStatus string `json:"last_attempt_status,omitempty"`
|
|
ProviderSummary string `json:"provider_summary,omitempty"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
UpdatedAtMS int64 `json:"updated_at_ms"`
|
|
SentAtMS *int64 `json:"sent_at_ms,omitempty"`
|
|
SuppressedAtMS *int64 `json:"suppressed_at_ms,omitempty"`
|
|
FailedAtMS *int64 `json:"failed_at_ms,omitempty"`
|
|
DeadLetteredAtMS *int64 `json:"dead_lettered_at_ms,omitempty"`
|
|
DeadLetter *DeadLetterResponse `json:"dead_letter,omitempty"`
|
|
}
|
|
|
|
// AttemptResponse stores one operator-facing delivery-attempt record.
|
|
type AttemptResponse struct {
|
|
DeliveryID string `json:"delivery_id"`
|
|
AttemptNo int `json:"attempt_no"`
|
|
ScheduledForMS int64 `json:"scheduled_for_ms"`
|
|
StartedAtMS *int64 `json:"started_at_ms,omitempty"`
|
|
FinishedAtMS *int64 `json:"finished_at_ms,omitempty"`
|
|
Status string `json:"status"`
|
|
ProviderClassification string `json:"provider_classification,omitempty"`
|
|
ProviderSummary string `json:"provider_summary,omitempty"`
|
|
}
|
|
|
|
// DeliveryAttemptsResponse stores the attempt history of one accepted
|
|
// delivery.
|
|
type DeliveryAttemptsResponse struct {
|
|
Items []AttemptResponse `json:"items"`
|
|
}
|
|
|
|
// DeliveryResendResponse stores the identifier of the clone delivery created
|
|
// by one resend request.
|
|
type DeliveryResendResponse struct {
|
|
DeliveryID string `json:"delivery_id"`
|
|
}
|
|
|
|
// DecodeDeliveryListInput validates one trusted operator delivery-list
|
|
// request and returns the normalized list input.
|
|
func DecodeDeliveryListInput(request *http.Request) (listdeliveries.Input, error) {
|
|
if request == nil {
|
|
return listdeliveries.Input{}, errors.New("delivery list request must not be nil")
|
|
}
|
|
|
|
query, err := decodeDeliveryListQuery(request)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
|
|
input, err := query.Normalize()
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
|
|
return input, nil
|
|
}
|
|
|
|
// DecodeDeliveryIDFromPath validates one trusted path delivery identifier.
|
|
func DecodeDeliveryIDFromPath(request *http.Request) (common.DeliveryID, error) {
|
|
if request == nil {
|
|
return "", errors.New("delivery lookup request must not be nil")
|
|
}
|
|
|
|
return parseDeliveryID(request.PathValue(deliveryIDPathValue))
|
|
}
|
|
|
|
// EncodeDeliveryListCursor encodes cursor into the frozen opaque base64url
|
|
// format `created_at_ms:delivery_id`.
|
|
func EncodeDeliveryListCursor(cursor listdeliveries.Cursor) (string, error) {
|
|
if err := cursor.Validate(); err != nil {
|
|
return "", fmt.Errorf("encode delivery list cursor: %w", err)
|
|
}
|
|
|
|
payload := fmt.Sprintf("%d:%s", cursor.CreatedAt.UTC().UnixMilli(), cursor.DeliveryID.String())
|
|
|
|
return base64.RawURLEncoding.EncodeToString([]byte(payload)), nil
|
|
}
|
|
|
|
// DecodeDeliveryListCursor decodes raw from the frozen opaque cursor format.
|
|
func DecodeDeliveryListCursor(raw string) (listdeliveries.Cursor, error) {
|
|
if strings.TrimSpace(raw) == "" {
|
|
return listdeliveries.Cursor{}, errors.New("cursor must not be empty")
|
|
}
|
|
if strings.TrimSpace(raw) != raw {
|
|
return listdeliveries.Cursor{}, errors.New("cursor must not contain surrounding whitespace")
|
|
}
|
|
|
|
payload, err := base64.RawURLEncoding.DecodeString(raw)
|
|
if err != nil {
|
|
return listdeliveries.Cursor{}, fmt.Errorf("decode cursor: %w", err)
|
|
}
|
|
|
|
createdAtRaw, deliveryIDRaw, ok := strings.Cut(string(payload), ":")
|
|
if !ok {
|
|
return listdeliveries.Cursor{}, errors.New("decode cursor: invalid cursor payload")
|
|
}
|
|
|
|
createdAtMS, err := strconv.ParseInt(createdAtRaw, 10, 64)
|
|
if err != nil {
|
|
return listdeliveries.Cursor{}, fmt.Errorf("decode cursor created_at_ms: %w", err)
|
|
}
|
|
|
|
cursor := listdeliveries.Cursor{
|
|
CreatedAt: time.UnixMilli(createdAtMS).UTC(),
|
|
DeliveryID: common.DeliveryID(deliveryIDRaw),
|
|
}
|
|
if err := cursor.Validate(); err != nil {
|
|
return listdeliveries.Cursor{}, fmt.Errorf("decode cursor: %w", err)
|
|
}
|
|
|
|
return cursor, nil
|
|
}
|
|
|
|
// Normalize converts the raw trusted query-string shape into the operator list
|
|
// input consumed by the service layer.
|
|
func (query DeliveryListQuery) Normalize() (listdeliveries.Input, error) {
|
|
var input listdeliveries.Input
|
|
|
|
recipient, err := parseOptionalEmail(query.Recipient, "recipient")
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
status, err := parseOptionalStatus(query.Status)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
source, err := parseOptionalSource(query.Source)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
templateID, err := parseOptionalTemplateID(query.TemplateID)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
idempotencyKey, err := parseOptionalIdempotencyKey(query.IdempotencyKey)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
fromCreatedAt, err := parseOptionalUnixMilli(query.FromCreatedAtMS, "from_created_at_ms")
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
toCreatedAt, err := parseOptionalUnixMilli(query.ToCreatedAtMS, "to_created_at_ms")
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
limit, err := parseOptionalLimit(query.Limit)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
cursor, err := parseOptionalCursor(query.Cursor)
|
|
if err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
|
|
input = listdeliveries.Input{
|
|
Limit: limit,
|
|
Cursor: cursor,
|
|
Filters: listdeliveries.Filters{
|
|
Recipient: recipient,
|
|
Status: status,
|
|
Source: source,
|
|
TemplateID: templateID,
|
|
IdempotencyKey: idempotencyKey,
|
|
FromCreatedAt: fromCreatedAt,
|
|
ToCreatedAt: toCreatedAt,
|
|
},
|
|
}
|
|
if err := input.Validate(); err != nil {
|
|
return listdeliveries.Input{}, err
|
|
}
|
|
|
|
return input, nil
|
|
}
|
|
|
|
func decodeDeliveryListQuery(request *http.Request) (DeliveryListQuery, error) {
|
|
values := request.URL.Query()
|
|
|
|
recipient, err := singleQueryValue(values, "recipient")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
status, err := singleQueryValue(values, "status")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
source, err := singleQueryValue(values, "source")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
templateID, err := singleQueryValue(values, "template_id")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
idempotencyKey, err := singleQueryValue(values, "idempotency_key")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
fromCreatedAtMS, err := singleQueryValue(values, "from_created_at_ms")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
toCreatedAtMS, err := singleQueryValue(values, "to_created_at_ms")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
limit, err := singleQueryValue(values, "limit")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
cursor, err := singleQueryValue(values, "cursor")
|
|
if err != nil {
|
|
return DeliveryListQuery{}, err
|
|
}
|
|
|
|
return DeliveryListQuery{
|
|
Recipient: recipient,
|
|
Status: status,
|
|
Source: source,
|
|
TemplateID: templateID,
|
|
IdempotencyKey: idempotencyKey,
|
|
FromCreatedAtMS: fromCreatedAtMS,
|
|
ToCreatedAtMS: toCreatedAtMS,
|
|
Limit: limit,
|
|
Cursor: cursor,
|
|
}, nil
|
|
}
|
|
|
|
func singleQueryValue(values map[string][]string, key string) (string, error) {
|
|
rawValues := values[key]
|
|
switch len(rawValues) {
|
|
case 0:
|
|
return "", nil
|
|
case 1:
|
|
return rawValues[0], nil
|
|
default:
|
|
return "", fmt.Errorf("query parameter %q must appear at most once", key)
|
|
}
|
|
}
|
|
|
|
func parseDeliveryID(raw string) (common.DeliveryID, error) {
|
|
deliveryID := common.DeliveryID(raw)
|
|
if err := deliveryID.Validate(); err != nil {
|
|
return "", fmt.Errorf("delivery id: %w", err)
|
|
}
|
|
|
|
return deliveryID, nil
|
|
}
|
|
|
|
func parseOptionalEmail(raw string, name string) (common.Email, error) {
|
|
if raw == "" {
|
|
return "", nil
|
|
}
|
|
|
|
email := common.Email(strings.TrimSpace(raw))
|
|
if err := email.Validate(); err != nil {
|
|
return "", fmt.Errorf("%s: %w", name, err)
|
|
}
|
|
|
|
return email, nil
|
|
}
|
|
|
|
func parseOptionalStatus(raw string) (deliverydomain.Status, error) {
|
|
if raw == "" {
|
|
return "", nil
|
|
}
|
|
|
|
status := deliverydomain.Status(strings.TrimSpace(raw))
|
|
if !status.IsKnown() {
|
|
return "", fmt.Errorf("status %q is unsupported", raw)
|
|
}
|
|
|
|
return status, nil
|
|
}
|
|
|
|
func parseOptionalSource(raw string) (deliverydomain.Source, error) {
|
|
if raw == "" {
|
|
return "", nil
|
|
}
|
|
|
|
source := deliverydomain.Source(strings.TrimSpace(raw))
|
|
if !source.IsKnown() {
|
|
return "", fmt.Errorf("source %q is unsupported", raw)
|
|
}
|
|
|
|
return source, nil
|
|
}
|
|
|
|
func parseOptionalTemplateID(raw string) (common.TemplateID, error) {
|
|
if raw == "" {
|
|
return "", nil
|
|
}
|
|
|
|
templateID := common.TemplateID(strings.TrimSpace(raw))
|
|
if err := templateID.Validate(); err != nil {
|
|
return "", fmt.Errorf("template id: %w", err)
|
|
}
|
|
|
|
return templateID, nil
|
|
}
|
|
|
|
func parseOptionalIdempotencyKey(raw string) (common.IdempotencyKey, error) {
|
|
if raw == "" {
|
|
return "", nil
|
|
}
|
|
|
|
key := common.IdempotencyKey(strings.TrimSpace(raw))
|
|
if err := key.Validate(); err != nil {
|
|
return "", fmt.Errorf("idempotency key: %w", err)
|
|
}
|
|
|
|
return key, nil
|
|
}
|
|
|
|
func parseOptionalUnixMilli(raw string, name string) (*time.Time, error) {
|
|
if raw == "" {
|
|
return nil, nil
|
|
}
|
|
|
|
value, err := strconv.ParseInt(strings.TrimSpace(raw), 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s: %w", name, err)
|
|
}
|
|
timestamp := time.UnixMilli(value).UTC()
|
|
if err := common.ValidateTimestamp(name, timestamp); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ×tamp, nil
|
|
}
|
|
|
|
func parseOptionalLimit(raw string) (int, error) {
|
|
if raw == "" {
|
|
return 0, nil
|
|
}
|
|
|
|
value, err := strconv.Atoi(strings.TrimSpace(raw))
|
|
if err != nil {
|
|
return 0, fmt.Errorf("limit: %w", err)
|
|
}
|
|
if value < 1 {
|
|
return 0, errors.New("limit must be at least 1")
|
|
}
|
|
|
|
return value, nil
|
|
}
|
|
|
|
func parseOptionalCursor(raw string) (*listdeliveries.Cursor, error) {
|
|
if raw == "" {
|
|
return nil, nil
|
|
}
|
|
|
|
cursor, err := DecodeDeliveryListCursor(raw)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &cursor, nil
|
|
}
|
|
|
|
func summaryResponseFromDelivery(record deliverydomain.Delivery) DeliverySummaryResponse {
|
|
return DeliverySummaryResponse{
|
|
DeliveryID: record.DeliveryID.String(),
|
|
ResendParentDeliveryID: record.ResendParentDeliveryID.String(),
|
|
Source: string(record.Source),
|
|
PayloadMode: string(record.PayloadMode),
|
|
TemplateID: record.TemplateID.String(),
|
|
To: emailStrings(record.Envelope.To),
|
|
Cc: emailStrings(record.Envelope.Cc),
|
|
Bcc: emailStrings(record.Envelope.Bcc),
|
|
ReplyTo: emailStrings(record.Envelope.ReplyTo),
|
|
Locale: record.Locale.String(),
|
|
LocaleFallbackUsed: record.LocaleFallbackUsed,
|
|
IdempotencyKey: record.IdempotencyKey.String(),
|
|
Status: string(record.Status),
|
|
AttemptCount: record.AttemptCount,
|
|
LastAttemptStatus: string(record.LastAttemptStatus),
|
|
ProviderSummary: record.ProviderSummary,
|
|
CreatedAtMS: record.CreatedAt.UTC().UnixMilli(),
|
|
UpdatedAtMS: record.UpdatedAt.UTC().UnixMilli(),
|
|
SentAtMS: unixMilliPtr(record.SentAt),
|
|
SuppressedAtMS: unixMilliPtr(record.SuppressedAt),
|
|
FailedAtMS: unixMilliPtr(record.FailedAt),
|
|
DeadLetteredAtMS: unixMilliPtr(record.DeadLetteredAt),
|
|
}
|
|
}
|
|
|
|
func detailResponseFromDelivery(record deliverydomain.Delivery, deadLetter *deliverydomain.DeadLetterEntry) DeliveryDetailResponse {
|
|
response := DeliveryDetailResponse{
|
|
DeliveryID: record.DeliveryID.String(),
|
|
ResendParentDeliveryID: record.ResendParentDeliveryID.String(),
|
|
Source: string(record.Source),
|
|
PayloadMode: string(record.PayloadMode),
|
|
TemplateID: record.TemplateID.String(),
|
|
TemplateVariables: cloneJSONObject(record.TemplateVariables),
|
|
To: emailStrings(record.Envelope.To),
|
|
Cc: emailStrings(record.Envelope.Cc),
|
|
Bcc: emailStrings(record.Envelope.Bcc),
|
|
ReplyTo: emailStrings(record.Envelope.ReplyTo),
|
|
Subject: record.Content.Subject,
|
|
TextBody: record.Content.TextBody,
|
|
HTMLBody: record.Content.HTMLBody,
|
|
Attachments: attachmentResponses(record.Attachments),
|
|
Locale: record.Locale.String(),
|
|
LocaleFallbackUsed: record.LocaleFallbackUsed,
|
|
IdempotencyKey: record.IdempotencyKey.String(),
|
|
Status: string(record.Status),
|
|
AttemptCount: record.AttemptCount,
|
|
LastAttemptStatus: string(record.LastAttemptStatus),
|
|
ProviderSummary: record.ProviderSummary,
|
|
CreatedAtMS: record.CreatedAt.UTC().UnixMilli(),
|
|
UpdatedAtMS: record.UpdatedAt.UTC().UnixMilli(),
|
|
SentAtMS: unixMilliPtr(record.SentAt),
|
|
SuppressedAtMS: unixMilliPtr(record.SuppressedAt),
|
|
FailedAtMS: unixMilliPtr(record.FailedAt),
|
|
DeadLetteredAtMS: unixMilliPtr(record.DeadLetteredAt),
|
|
}
|
|
if deadLetter != nil {
|
|
response.DeadLetter = &DeadLetterResponse{
|
|
DeliveryID: deadLetter.DeliveryID.String(),
|
|
FinalAttemptNo: deadLetter.FinalAttemptNo,
|
|
FailureClassification: deadLetter.FailureClassification,
|
|
ProviderSummary: deadLetter.ProviderSummary,
|
|
CreatedAtMS: deadLetter.CreatedAt.UTC().UnixMilli(),
|
|
RecoveryHint: deadLetter.RecoveryHint,
|
|
}
|
|
}
|
|
|
|
return response
|
|
}
|
|
|
|
func attemptResponseFromRecord(record attempt.Attempt) AttemptResponse {
|
|
return AttemptResponse{
|
|
DeliveryID: record.DeliveryID.String(),
|
|
AttemptNo: record.AttemptNo,
|
|
ScheduledForMS: record.ScheduledFor.UTC().UnixMilli(),
|
|
StartedAtMS: unixMilliPtr(record.StartedAt),
|
|
FinishedAtMS: unixMilliPtr(record.FinishedAt),
|
|
Status: string(record.Status),
|
|
ProviderClassification: record.ProviderClassification,
|
|
ProviderSummary: record.ProviderSummary,
|
|
}
|
|
}
|
|
|
|
func attachmentResponses(attachments []common.AttachmentMetadata) []AttachmentResponse {
|
|
if len(attachments) == 0 {
|
|
return []AttachmentResponse{}
|
|
}
|
|
|
|
result := make([]AttachmentResponse, len(attachments))
|
|
for index, attachment := range attachments {
|
|
result[index] = AttachmentResponse{
|
|
Filename: attachment.Filename,
|
|
ContentType: attachment.ContentType,
|
|
SizeBytes: attachment.SizeBytes,
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func emailStrings(values []common.Email) []string {
|
|
if len(values) == 0 {
|
|
return []string{}
|
|
}
|
|
|
|
result := make([]string, len(values))
|
|
for index, value := range values {
|
|
result[index] = value.String()
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func unixMilliPtr(value *time.Time) *int64 {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
|
|
encoded := value.UTC().UnixMilli()
|
|
return &encoded
|
|
}
|
|
|
|
func cloneJSONObject(value map[string]any) map[string]any {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
|
|
cloned := make(map[string]any, len(value))
|
|
for key, entry := range value {
|
|
cloned[key] = entry
|
|
}
|
|
|
|
return cloned
|
|
}
|