This commit is contained in:
Codex Local
@@ -0,0 +1,347 @@
|
||||
package billing
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"sort"
|
||||
"time"
|
||||
|
||||
"data-terminal-cloud/internal/identity"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
const maxUsageOverviewRange = 366 * 24 * time.Hour
|
||||
|
||||
type UsageOverviewScope struct {
|
||||
TenantID string `json:"tenant_id"`
|
||||
TenantName string `json:"tenant_name"`
|
||||
HouseholdID string `json:"household_id,omitempty"`
|
||||
HouseholdName string `json:"household_name,omitempty"`
|
||||
DeviceID string `json:"device_id,omitempty"`
|
||||
DeviceName string `json:"device_name,omitempty"`
|
||||
}
|
||||
|
||||
type UsageOverviewDay struct {
|
||||
Date string `json:"date"`
|
||||
DurationMS int64 `json:"duration_ms"`
|
||||
ConversationCount int `json:"conversation_count"`
|
||||
CostMicros int64 `json:"cost_micros"`
|
||||
}
|
||||
|
||||
type UsageOverviewDevice struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
HouseholdID string `json:"household_id"`
|
||||
HouseholdName string `json:"household_name"`
|
||||
DurationMS int64 `json:"duration_ms"`
|
||||
ConversationCount int `json:"conversation_count"`
|
||||
CostMicros int64 `json:"cost_micros"`
|
||||
}
|
||||
|
||||
type UsageOverviewConversation struct {
|
||||
ID string `json:"id"`
|
||||
HouseholdID string `json:"household_id"`
|
||||
HouseholdName string `json:"household_name"`
|
||||
DeviceID string `json:"device_id"`
|
||||
DeviceName string `json:"device_name"`
|
||||
SubjectName string `json:"subject_name"`
|
||||
Status string `json:"status"`
|
||||
StartedAt time.Time `json:"started_at"`
|
||||
EndedAt *time.Time `json:"ended_at,omitempty"`
|
||||
DurationMS int64 `json:"duration_ms"`
|
||||
CostMicros int64 `json:"cost_micros"`
|
||||
}
|
||||
|
||||
type UsageOverview struct {
|
||||
From time.Time `json:"from"`
|
||||
To time.Time `json:"to"`
|
||||
Timezone string `json:"timezone"`
|
||||
Scope UsageOverviewScope `json:"scope"`
|
||||
TotalDurationMS int64 `json:"total_duration_ms"`
|
||||
TodayDurationMS int64 `json:"today_duration_ms"`
|
||||
ConversationCount int `json:"conversation_count"`
|
||||
AverageDurationMS int64 `json:"average_duration_ms"`
|
||||
ActiveDays int `json:"active_days"`
|
||||
CurrentStreakDays int `json:"current_streak_days"`
|
||||
LongestStreakDays int `json:"longest_streak_days"`
|
||||
CostMicros int64 `json:"cost_micros"`
|
||||
Currency string `json:"currency"`
|
||||
CostAvailable bool `json:"cost_available"`
|
||||
Daily []UsageOverviewDay `json:"daily"`
|
||||
Devices []UsageOverviewDevice `json:"devices"`
|
||||
RecentConversations []UsageOverviewConversation `json:"recent_conversations"`
|
||||
}
|
||||
|
||||
type usageOverviewTarget struct {
|
||||
tenantID, tenantPublicID, tenantName string
|
||||
householdID, householdPublicID, householdName string
|
||||
deviceID, devicePublicID, deviceName string
|
||||
}
|
||||
|
||||
type usageOverviewRow struct {
|
||||
conversationID, householdID, householdName string
|
||||
deviceID, deviceName, subjectName, status string
|
||||
startedAt time.Time
|
||||
endedAt *time.Time
|
||||
costMicros int64
|
||||
currency string
|
||||
hasCost bool
|
||||
}
|
||||
|
||||
func (s *Service) FamilyUsageOverview(ctx context.Context, principal identity.Principal, householdPublicID, devicePublicID, timezone string, from, to time.Time) (UsageOverview, error) {
|
||||
if _, err := uuid.Parse(householdPublicID); err != nil {
|
||||
return UsageOverview{}, ErrInvalid
|
||||
}
|
||||
target := usageOverviewTarget{}
|
||||
var role identity.Role
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT t.id::text,t.public_id::text,t.name,h.id::text,h.public_id::text,h.name,hm.role
|
||||
FROM user_account ua
|
||||
JOIN tenant t ON t.id=ua.tenant_id AND t.status='active'
|
||||
JOIN household_member hm ON hm.user_id=ua.id AND hm.tenant_id=ua.tenant_id AND hm.status='active'
|
||||
JOIN household h ON h.id=hm.household_id AND h.tenant_id=hm.tenant_id AND h.status<>'deleted'
|
||||
WHERE h.public_id=$1::uuid AND ua.oidc_issuer=$2 AND ua.oidc_subject=$3 AND ua.status='active'`,
|
||||
householdPublicID, principal.Issuer, principal.Subject).Scan(
|
||||
&target.tenantID, &target.tenantPublicID, &target.tenantName,
|
||||
&target.householdID, &target.householdPublicID, &target.householdName, &role)
|
||||
if errors.Is(err, pgx.ErrNoRows) || (err == nil && !identity.Can(role, identity.CapabilityHouseholdRead)) {
|
||||
return UsageOverview{}, ErrAccessDenied
|
||||
}
|
||||
if err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
if err = s.resolveUsageOverviewDevice(ctx, &target, devicePublicID, true); err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
return s.buildUsageOverview(ctx, target, timezone, from, to)
|
||||
}
|
||||
|
||||
func (s *Service) OpsUsageOverview(ctx context.Context, principal identity.Principal, tenantPublicID, householdPublicID, devicePublicID, timezone string, from, to time.Time) (UsageOverview, error) {
|
||||
currentActor, err := s.resolveActor(ctx, principal, tenantPublicID, "ops_viewer", "ops_operator", "ops_approver", "ops_admin")
|
||||
if err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
target := usageOverviewTarget{tenantID: currentActor.tenantID, tenantPublicID: currentActor.tenantPublicID}
|
||||
if err = s.pool.QueryRow(ctx, `SELECT name FROM tenant WHERE id=$1::uuid`, target.tenantID).Scan(&target.tenantName); err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
if householdPublicID != "" {
|
||||
if _, parseErr := uuid.Parse(householdPublicID); parseErr != nil {
|
||||
return UsageOverview{}, ErrInvalid
|
||||
}
|
||||
err = s.pool.QueryRow(ctx, `SELECT id::text,public_id::text,name FROM household WHERE tenant_id=$1::uuid AND public_id=$2::uuid AND status<>'deleted'`, target.tenantID, householdPublicID).Scan(&target.householdID, &target.householdPublicID, &target.householdName)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return UsageOverview{}, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
}
|
||||
if err = s.resolveUsageOverviewDevice(ctx, &target, devicePublicID, false); err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
return s.buildUsageOverview(ctx, target, timezone, from, to)
|
||||
}
|
||||
|
||||
func (s *Service) resolveUsageOverviewDevice(ctx context.Context, target *usageOverviewTarget, devicePublicID string, family bool) error {
|
||||
if devicePublicID == "" {
|
||||
return nil
|
||||
}
|
||||
if _, err := uuid.Parse(devicePublicID); err != nil {
|
||||
return ErrInvalid
|
||||
}
|
||||
query := `SELECT d.id::text,d.public_id::text,d.model FROM device d WHERE d.tenant_id=$1::uuid AND d.public_id=$2::uuid`
|
||||
args := []any{target.tenantID, devicePublicID}
|
||||
if target.householdID != "" {
|
||||
query += ` AND (
|
||||
EXISTS(SELECT 1 FROM device_binding b WHERE b.tenant_id=d.tenant_id AND b.device_id=d.id AND b.household_id=$3::uuid AND b.unbound_at IS NULL)
|
||||
OR EXISTS(SELECT 1 FROM conversation c WHERE c.tenant_id=d.tenant_id AND c.device_id=d.id AND c.household_id=$3::uuid)
|
||||
)`
|
||||
args = append(args, target.householdID)
|
||||
}
|
||||
err := s.pool.QueryRow(ctx, query, args...).Scan(&target.deviceID, &target.devicePublicID, &target.deviceName)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
if family {
|
||||
return ErrAccessDenied
|
||||
}
|
||||
return ErrNotFound
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Service) buildUsageOverview(ctx context.Context, target usageOverviewTarget, timezone string, from, to time.Time) (UsageOverview, error) {
|
||||
location, err := validateUsageOverviewRange(timezone, from, to)
|
||||
if err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
from = from.UTC()
|
||||
to = to.UTC()
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT c.public_id::text,h.public_id::text,h.name,d.public_id::text,d.model,sp.preferred_name,c.status,c.started_at,c.ended_at,
|
||||
COALESCE(cost.cost_micros,0)::bigint,COALESCE(cost.currency,''),COALESCE(cost.has_cost,false)
|
||||
FROM conversation c
|
||||
JOIN household h ON h.id=c.household_id AND h.tenant_id=c.tenant_id
|
||||
JOIN device d ON d.id=c.device_id AND d.tenant_id=c.tenant_id
|
||||
JOIN subject_profile sp ON sp.id=c.subject_id AND sp.tenant_id=c.tenant_id
|
||||
LEFT JOIN LATERAL (
|
||||
SELECT SUM(ccl.cost_micros)::bigint AS cost_micros,MIN(ccl.currency) AS currency,COUNT(*)>0 AS has_cost
|
||||
FROM conversation_cost_line ccl WHERE ccl.conversation_id=c.id
|
||||
) cost ON true
|
||||
WHERE c.tenant_id=$1::uuid AND c.started_at IS NOT NULL AND c.started_at>=$2 AND c.started_at<$3
|
||||
AND ($4::uuid IS NULL OR c.household_id=$4::uuid)
|
||||
AND ($5::uuid IS NULL OR c.device_id=$5::uuid)
|
||||
ORDER BY c.started_at DESC,c.public_id`, target.tenantID, from, to, nullableUUID(target.householdID), nullableUUID(target.deviceID))
|
||||
if err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
result := UsageOverview{
|
||||
From: from, To: to, Timezone: timezone,
|
||||
Scope: UsageOverviewScope{TenantID: target.tenantPublicID, TenantName: target.tenantName, HouseholdID: target.householdPublicID, HouseholdName: target.householdName, DeviceID: target.devicePublicID, DeviceName: target.deviceName},
|
||||
Daily: []UsageOverviewDay{}, Devices: []UsageOverviewDevice{}, RecentConversations: []UsageOverviewConversation{},
|
||||
}
|
||||
daily := map[string]*UsageOverviewDay{}
|
||||
devices := map[string]*UsageOverviewDevice{}
|
||||
activeDates := map[string]struct{}{}
|
||||
currencies := map[string]struct{}{}
|
||||
today := time.Now().In(location).Format("2006-01-02")
|
||||
for rows.Next() {
|
||||
var row usageOverviewRow
|
||||
if err = rows.Scan(&row.conversationID, &row.householdID, &row.householdName, &row.deviceID, &row.deviceName, &row.subjectName, &row.status, &row.startedAt, &row.endedAt, &row.costMicros, &row.currency, &row.hasCost); err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
duration := conversationDurationMS(row.startedAt, row.endedAt, to)
|
||||
date := row.startedAt.In(location).Format("2006-01-02")
|
||||
day := daily[date]
|
||||
if day == nil {
|
||||
day = &UsageOverviewDay{Date: date}
|
||||
daily[date] = day
|
||||
}
|
||||
day.DurationMS += duration
|
||||
day.ConversationCount++
|
||||
day.CostMicros += row.costMicros
|
||||
activeDates[date] = struct{}{}
|
||||
|
||||
device := devices[row.deviceID]
|
||||
if device == nil {
|
||||
device = &UsageOverviewDevice{ID: row.deviceID, Name: row.deviceName, HouseholdID: row.householdID, HouseholdName: row.householdName}
|
||||
devices[row.deviceID] = device
|
||||
}
|
||||
device.DurationMS += duration
|
||||
device.ConversationCount++
|
||||
device.CostMicros += row.costMicros
|
||||
|
||||
result.TotalDurationMS += duration
|
||||
result.ConversationCount++
|
||||
result.CostMicros += row.costMicros
|
||||
if date == today {
|
||||
result.TodayDurationMS += duration
|
||||
}
|
||||
if row.hasCost {
|
||||
result.CostAvailable = true
|
||||
currencies[row.currency] = struct{}{}
|
||||
}
|
||||
if len(result.RecentConversations) < 20 {
|
||||
result.RecentConversations = append(result.RecentConversations, UsageOverviewConversation{
|
||||
ID: row.conversationID, HouseholdID: row.householdID, HouseholdName: row.householdName,
|
||||
DeviceID: row.deviceID, DeviceName: row.deviceName, SubjectName: row.subjectName, Status: row.status,
|
||||
StartedAt: row.startedAt, EndedAt: row.endedAt, DurationMS: duration, CostMicros: row.costMicros,
|
||||
})
|
||||
}
|
||||
}
|
||||
if err = rows.Err(); err != nil {
|
||||
return UsageOverview{}, err
|
||||
}
|
||||
if len(currencies) > 1 {
|
||||
return UsageOverview{}, errors.New("usage overview contains multiple currencies")
|
||||
}
|
||||
for currency := range currencies {
|
||||
result.Currency = currency
|
||||
}
|
||||
if result.ConversationCount > 0 {
|
||||
result.AverageDurationMS = result.TotalDurationMS / int64(result.ConversationCount)
|
||||
}
|
||||
for _, day := range daily {
|
||||
result.Daily = append(result.Daily, *day)
|
||||
}
|
||||
sort.Slice(result.Daily, func(i, j int) bool { return result.Daily[i].Date < result.Daily[j].Date })
|
||||
for _, device := range devices {
|
||||
result.Devices = append(result.Devices, *device)
|
||||
}
|
||||
sort.Slice(result.Devices, func(i, j int) bool {
|
||||
if result.Devices[i].DurationMS == result.Devices[j].DurationMS {
|
||||
return result.Devices[i].ID < result.Devices[j].ID
|
||||
}
|
||||
return result.Devices[i].DurationMS > result.Devices[j].DurationMS
|
||||
})
|
||||
result.ActiveDays = len(activeDates)
|
||||
result.CurrentStreakDays, result.LongestStreakDays = usageStreaks(activeDates, time.Now().In(location))
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func validateUsageOverviewRange(timezone string, from, to time.Time) (*time.Location, error) {
|
||||
if timezone == "" || from.IsZero() || !to.After(from) || to.Sub(from) > maxUsageOverviewRange || to.After(time.Now().UTC().Add(5*time.Minute)) {
|
||||
return nil, ErrInvalid
|
||||
}
|
||||
location, err := time.LoadLocation(timezone)
|
||||
if err != nil {
|
||||
return nil, ErrInvalid
|
||||
}
|
||||
return location, nil
|
||||
}
|
||||
|
||||
func conversationDurationMS(startedAt time.Time, endedAt *time.Time, rangeEnd time.Time) int64 {
|
||||
end := rangeEnd
|
||||
if endedAt != nil && endedAt.Before(end) {
|
||||
end = *endedAt
|
||||
}
|
||||
if end.Before(startedAt) {
|
||||
return 0
|
||||
}
|
||||
return end.Sub(startedAt).Milliseconds()
|
||||
}
|
||||
|
||||
func usageStreaks(active map[string]struct{}, now time.Time) (current, longest int) {
|
||||
if len(active) == 0 {
|
||||
return 0, 0
|
||||
}
|
||||
dates := make([]time.Time, 0, len(active))
|
||||
for value := range active {
|
||||
date, err := time.ParseInLocation("2006-01-02", value, now.Location())
|
||||
if err == nil {
|
||||
dates = append(dates, date)
|
||||
}
|
||||
}
|
||||
sort.Slice(dates, func(i, j int) bool { return dates[i].Before(dates[j]) })
|
||||
streak := 0
|
||||
for index, date := range dates {
|
||||
if index == 0 || date.Equal(dates[index-1].AddDate(0, 0, 1)) {
|
||||
streak++
|
||||
} else {
|
||||
streak = 1
|
||||
}
|
||||
if streak > longest {
|
||||
longest = streak
|
||||
}
|
||||
}
|
||||
latest := dates[len(dates)-1]
|
||||
today, _ := time.ParseInLocation("2006-01-02", now.Format("2006-01-02"), now.Location())
|
||||
if latest.Before(today.AddDate(0, 0, -1)) {
|
||||
return 0, longest
|
||||
}
|
||||
current = 1
|
||||
for index := len(dates) - 1; index > 0 && dates[index].Equal(dates[index-1].AddDate(0, 0, 1)); index-- {
|
||||
current++
|
||||
}
|
||||
return current, longest
|
||||
}
|
||||
|
||||
func nullableUUID(value string) any {
|
||||
if value == "" {
|
||||
return nil
|
||||
}
|
||||
return value
|
||||
}
|
||||
Reference in New Issue
Block a user