ampelmaennchen.git

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

package db

import (
	"apiote.xyz/p/ampelmaennchen/accounts"

	"database/sql"
	"errors"
	"fmt"
	"time"
)

func GetValidSubscription(userID string) (accounts.Subscription, error) {
	subscription := accounts.Subscription{}
	row := db.QueryRow("select plan, valid_since, validity from subscriptions where subscribed_user = $1 and valid_since <= now() and valid_since + valididy >= now()", userID)
	err := row.Scan(&subscription.Plan, &subscription.ValidSince, &subscription.Validity)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return accounts.Subscription{
				Plan:       accounts.SEAT_BACK,
				ValidSince: time.Now(),
				Validity:   100 * 12,
			}, nil
		}
		return subscription, fmt.Errorf("while selecting subscription: %w", err)
	}
	return subscription, nil
}

func GetSubscriptions(userID string) ([]accounts.Subscription, error) {
	subscriptions := []accounts.Subscription{}
	c, err := db.Query("select plan, valid_since, validity from subscriptions where subscribed_user = $1")
	if err != nil {
		return subscriptions, fmt.Errorf("while selecting subscriptions: %w", err)
	}
	for c.Next() {
		var (
			rawPlan    string
			plan       accounts.Seat
			validSince time.Time
			validity   int
		)
		err = c.Scan(&rawPlan, &validSince, &validity)
		if err != nil {
			return subscriptions, fmt.Errorf("while scanning subscription: %w", err)
		}
		plan, err = accounts.ParseSeat(rawPlan)
		if err != nil {
			return subscriptions, fmt.Errorf("while parsing subscription plan: %w", err)
		}
		subscriptions = append(subscriptions, accounts.Subscription{
			Plan:       plan,
			ValidSince: validSince,
			Validity:   validity,
		})
	}
	if len(subscriptions) == 0 {
		return []accounts.Subscription{
			{Plan: accounts.SEAT_BACK, ValidSince: time.Now(), Validity: 100 * 12},
		}, nil
	} else {
		return subscriptions, nil
	}
}

func HasSubscriptionKey() (bool, error) {
	var seed []byte
	row := db.QueryRow("select seed from keys")
	err := row.Scan(&seed)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return false, nil
		}
		return false, err
	}
	return true, nil
}

func GetSubscriptionKey() ([]byte, error) {
	var seed []byte
	row := db.QueryRow("select seed from keys")
	err := row.Scan(&seed)
	return seed, err
}

func SaveSubscriptionKey(seed []byte) error {
	_, err := db.Exec("insert into keys values($1)", seed)
	return err
}

func IsTicketUnused(ticket accounts.SubscriptionTicket) (bool, error) {
	var subscribedUser *string
	row := db.QueryRow("select subscribed_user from subscriptions")
	err := row.Scan(&subscribedUser)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return true, nil
		}
		return false, err
	}
	return subscribedUser == nil, nil
}

func ValidateTicket(ticket accounts.SubscriptionTicket, userID string) error {
	_, err := db.Exec("insert into subscriptions values($1, $2, $3, $4, $5, $6, $7) on conflict(id) do update set subscribed_user = $2, valid_since = $3", ticket.ID, userID, time.Now(), ticket.Validity, ticket.Plan, ticket.Signature, ticket.Creator)
	return err
}