225 lines
8.3 KiB
Go
225 lines
8.3 KiB
Go
package analytics
|
||
|
||
import (
|
||
"context"
|
||
"encoding/base64"
|
||
"errors"
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/jackc/pgx/v5"
|
||
)
|
||
|
||
type DetailFilter struct {
|
||
View string
|
||
FailureStage string
|
||
TerminalID string
|
||
Status string
|
||
MinAmountRial *int64
|
||
MaxAmountRial *int64
|
||
Cursor string
|
||
Limit int
|
||
}
|
||
|
||
func (f DetailFilter) Validate() error {
|
||
views := map[string]bool{"ALL": true, "UNVERIFIED_PAID": true, "FAILED": true, "RETRIED": true}
|
||
if !views[f.View] {
|
||
return errors.New("analytics: invalid detail view")
|
||
}
|
||
statuses := map[string]bool{"": true, "Paid": true, "Verified": true, "Failed": true, "Reversed": true}
|
||
if !statuses[f.Status] {
|
||
return errors.New("analytics: invalid session status")
|
||
}
|
||
stages := map[string]bool{"": true, "NO_ATTEMPT": true, "REACHED_BANK": true, "OTHER_OBSERVED": true}
|
||
if !stages[f.FailureStage] || (f.FailureStage != "" && f.View != "FAILED") {
|
||
return errors.New("analytics: invalid failure stage")
|
||
}
|
||
if f.MinAmountRial != nil && *f.MinAmountRial < 0 || f.MaxAmountRial != nil && *f.MaxAmountRial < 0 {
|
||
return errors.New("analytics: amount bounds must be non-negative")
|
||
}
|
||
if f.MinAmountRial != nil && f.MaxAmountRial != nil && *f.MinAmountRial > *f.MaxAmountRial {
|
||
return errors.New("analytics: minimum amount exceeds maximum")
|
||
}
|
||
if f.Limit < 1 || f.Limit > 100 {
|
||
return errors.New("analytics: detail limit outside range")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type Attempt struct {
|
||
Sequence int `json:"sequence"`
|
||
Status string `json:"status"`
|
||
CreatedAt *time.Time `json:"createdAt"`
|
||
InitTimeMS *int `json:"initTimeMs"`
|
||
VerifyTimeMS *int `json:"verifyTimeMs"`
|
||
}
|
||
type Detail struct {
|
||
SessionID string `json:"sessionId"`
|
||
TerminalID string `json:"terminalId"`
|
||
SessionStatus string `json:"sessionStatus"`
|
||
AmountRial int64 `json:"amountRial"`
|
||
FeeAmountRial int64 `json:"feeAmountRial"`
|
||
CreatedAt time.Time `json:"createdAt"`
|
||
ExpiresAt *time.Time `json:"expiresAt"`
|
||
VerifiedAt *time.Time `json:"verifiedAt"`
|
||
SettledAt *time.Time `json:"settledAt"`
|
||
AttemptCount int `json:"attemptCount"`
|
||
FailureStage *string `json:"failureStage"`
|
||
Attempts []Attempt `json:"attempts"`
|
||
}
|
||
|
||
func (s *Service) Details(ctx context.Context, merchantID int64, period Period, filter DetailFilter) ([]Detail, string, error) {
|
||
if filter.Limit <= 0 {
|
||
filter.Limit = 25
|
||
}
|
||
if err := filter.Validate(); err != nil {
|
||
return nil, "", err
|
||
}
|
||
offset := 0
|
||
if filter.Cursor != "" {
|
||
decoded, err := base64.RawURLEncoding.DecodeString(filter.Cursor)
|
||
if err != nil {
|
||
return nil, "", errors.New("analytics: invalid cursor")
|
||
}
|
||
offset, err = strconv.Atoi(string(decoded))
|
||
if err != nil || offset < 0 {
|
||
return nil, "", errors.New("analytics: invalid cursor")
|
||
}
|
||
}
|
||
statusPredicate := "TRUE"
|
||
switch filter.View {
|
||
case "ALL":
|
||
statusPredicate = "TRUE"
|
||
case "UNVERIFIED_PAID":
|
||
statusPredicate = "ps.status='Paid'"
|
||
case "FAILED":
|
||
statusPredicate = "ps.status='Failed'"
|
||
case "RETRIED":
|
||
statusPredicate = "(SELECT count(*) FROM payment_attempts x WHERE x.session_id=ps.id)>1"
|
||
}
|
||
query := `SELECT ps.id,ps.source_key,t.source_key,ps.status,ps.amount_rial,ps.fee_amount_rial,ps.created_at,ps.expires_at,ps.verified_at,ps.settled_at,
|
||
count(pa.id)::int,coalesce(bool_or(pa.status='InBank'),false) FROM payment_sessions ps JOIN terminals t ON t.id=ps.terminal_id LEFT JOIN payment_attempts pa ON pa.session_id=ps.id
|
||
WHERE ps.merchant_id=$1 AND ps.created_at>=$2 AND ps.created_at<$3 AND ` + statusPredicate + `
|
||
AND ($4='' OR t.source_key=$4)
|
||
AND ($5='' OR
|
||
($5='NO_ATTEMPT' AND NOT EXISTS (SELECT 1 FROM payment_attempts fa WHERE fa.session_id=ps.id)) OR
|
||
($5='REACHED_BANK' AND EXISTS (SELECT 1 FROM payment_attempts fa WHERE fa.session_id=ps.id AND fa.status='InBank')) OR
|
||
($5='OTHER_OBSERVED' AND EXISTS (SELECT 1 FROM payment_attempts fa WHERE fa.session_id=ps.id) AND NOT EXISTS (SELECT 1 FROM payment_attempts fa WHERE fa.session_id=ps.id AND fa.status='InBank')))
|
||
AND ($6='' OR ps.status=$6) AND ($7::bigint IS NULL OR ps.amount_rial >= $7) AND ($8::bigint IS NULL OR ps.amount_rial <= $8)
|
||
GROUP BY ps.id,t.source_key ORDER BY ps.created_at DESC,ps.id DESC LIMIT $9 OFFSET $10`
|
||
rows, err := s.pool.Query(ctx, query, merchantID, period.StartAt, period.EndAt, filter.TerminalID, filter.FailureStage, filter.Status, filter.MinAmountRial, filter.MaxAmountRial, filter.Limit+1, offset)
|
||
if err != nil {
|
||
return nil, "", fmt.Errorf("querying session details: %w", err)
|
||
}
|
||
defer rows.Close()
|
||
details := make([]Detail, 0, filter.Limit)
|
||
ids := make([]int64, 0, filter.Limit)
|
||
hasMore := false
|
||
for rows.Next() {
|
||
var id int64
|
||
var reachedBank bool
|
||
var d Detail
|
||
if err := rows.Scan(&id, &d.SessionID, &d.TerminalID, &d.SessionStatus, &d.AmountRial, &d.FeeAmountRial, &d.CreatedAt, &d.ExpiresAt, &d.VerifiedAt, &d.SettledAt, &d.AttemptCount, &reachedBank); err != nil {
|
||
return nil, "", fmt.Errorf("scanning session detail: %w", err)
|
||
}
|
||
d.SessionID = "ses_" + d.SessionID
|
||
d.Attempts = []Attempt{}
|
||
setFailureStage(&d, reachedBank)
|
||
if len(details) == filter.Limit {
|
||
hasMore = true
|
||
break
|
||
}
|
||
details = append(details, d)
|
||
ids = append(ids, id)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, "", fmt.Errorf("iterating session details: %w", err)
|
||
}
|
||
for i, id := range ids {
|
||
attempts, err := s.attempts(ctx, id)
|
||
if err != nil {
|
||
return nil, "", err
|
||
}
|
||
details[i].Attempts = attempts
|
||
}
|
||
next := ""
|
||
if hasMore {
|
||
next = base64.RawURLEncoding.EncodeToString([]byte(strconv.Itoa(offset + filter.Limit)))
|
||
}
|
||
return details, next, nil
|
||
}
|
||
|
||
func (s *Service) Session(ctx context.Context, merchantID int64, sessionID string) (Detail, bool, error) {
|
||
sourceKey, valid := sessionSourceKey(sessionID)
|
||
if !valid {
|
||
return Detail{}, false, nil
|
||
}
|
||
query := `SELECT ps.id,ps.source_key,t.source_key,ps.status,ps.amount_rial,ps.fee_amount_rial,ps.created_at,ps.expires_at,ps.verified_at,ps.settled_at,
|
||
count(pa.id)::int,coalesce(bool_or(pa.status='InBank'),false) FROM payment_sessions ps JOIN terminals t ON t.id=ps.terminal_id LEFT JOIN payment_attempts pa ON pa.session_id=ps.id
|
||
WHERE ps.merchant_id=$1 AND ps.source_key=$2 GROUP BY ps.id,t.source_key`
|
||
var id int64
|
||
var reachedBank bool
|
||
var detail Detail
|
||
err := s.pool.QueryRow(ctx, query, merchantID, sourceKey).Scan(&id, &detail.SessionID, &detail.TerminalID, &detail.SessionStatus, &detail.AmountRial, &detail.FeeAmountRial, &detail.CreatedAt, &detail.ExpiresAt, &detail.VerifiedAt, &detail.SettledAt, &detail.AttemptCount, &reachedBank)
|
||
if errors.Is(err, pgx.ErrNoRows) {
|
||
return Detail{}, false, nil
|
||
}
|
||
if err != nil {
|
||
return Detail{}, false, fmt.Errorf("querying session: %w", err)
|
||
}
|
||
detail.SessionID = "ses_" + detail.SessionID
|
||
detail.Attempts, err = s.attempts(ctx, id)
|
||
if err != nil {
|
||
return Detail{}, false, err
|
||
}
|
||
setFailureStage(&detail, reachedBank)
|
||
return detail, true, nil
|
||
}
|
||
|
||
func (s *Service) attempts(ctx context.Context, sessionID int64) ([]Attempt, error) {
|
||
rows, err := s.pool.Query(ctx, `SELECT sequence,status,created_at,init_time_ms,verify_time_ms FROM payment_attempts WHERE session_id=$1 ORDER BY sequence`, sessionID)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("querying attempts: %w", err)
|
||
}
|
||
attempts, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (Attempt, error) {
|
||
var attempt Attempt
|
||
err := row.Scan(&attempt.Sequence, &attempt.Status, &attempt.CreatedAt, &attempt.InitTimeMS, &attempt.VerifyTimeMS)
|
||
return attempt, err
|
||
})
|
||
if err != nil {
|
||
return nil, fmt.Errorf("collecting attempts: %w", err)
|
||
}
|
||
return attempts, nil
|
||
}
|
||
|
||
func setFailureStage(detail *Detail, reachedBank bool) {
|
||
if detail.SessionStatus != "Failed" {
|
||
return
|
||
}
|
||
stage := "OTHER_OBSERVED"
|
||
if detail.AttemptCount == 0 {
|
||
stage = "NO_ATTEMPT"
|
||
} else if reachedBank {
|
||
stage = "REACHED_BANK"
|
||
}
|
||
detail.FailureStage = &stage
|
||
}
|
||
|
||
func sessionSourceKey(sessionID string) (string, bool) {
|
||
if !strings.HasPrefix(sessionID, "ses_") || len(sessionID) <= len("ses_") {
|
||
return "", false
|
||
}
|
||
return strings.TrimPrefix(sessionID, "ses_"), true
|
||
}
|
||
|
||
func terminalDisplayName(terminalID string) string {
|
||
suffix := terminalID
|
||
if len(suffix) > 4 {
|
||
suffix = suffix[len(suffix)-4:]
|
||
}
|
||
digits := strings.NewReplacer("0", "۰", "1", "۱", "2", "۲", "3", "۳", "4", "۴", "5", "۵", "6", "۶", "7", "۷", "8", "۸", "9", "۹")
|
||
return "پایانه " + digits.Replace(suffix)
|
||
}
|