288 lines
7.3 KiB
Go
288 lines
7.3 KiB
Go
package storage
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"synlotto-website/models"
|
|
"time"
|
|
)
|
|
|
|
func GetSyndicatesByOwner(db *sql.DB, ownerID int) []models.Syndicate {
|
|
rows, err := db.Query(`
|
|
SELECT id, name, description, created_at, owner_id
|
|
FROM syndicates
|
|
WHERE owner_id = ?`, ownerID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer rows.Close()
|
|
|
|
var syndicates []models.Syndicate
|
|
for rows.Next() {
|
|
var s models.Syndicate
|
|
err := rows.Scan(&s.ID, &s.Name, &s.Description, &s.CreatedAt, &s.OwnerID)
|
|
if err == nil {
|
|
syndicates = append(syndicates, s)
|
|
}
|
|
}
|
|
return syndicates
|
|
}
|
|
|
|
func GetSyndicatesByMember(db *sql.DB, userID int) []models.Syndicate {
|
|
rows, err := db.Query(`
|
|
SELECT s.id, s.name, s.description, s.created_at, s.owner_id
|
|
FROM syndicates s
|
|
JOIN syndicate_members m ON s.id = m.syndicate_id
|
|
WHERE m.user_id = ?`, userID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer rows.Close()
|
|
|
|
var syndicates []models.Syndicate
|
|
for rows.Next() {
|
|
var s models.Syndicate
|
|
err := rows.Scan(&s.ID, &s.Name, &s.Description, &s.CreatedAt, &s.OwnerID)
|
|
if err == nil {
|
|
syndicates = append(syndicates, s)
|
|
}
|
|
}
|
|
return syndicates
|
|
}
|
|
|
|
func GetSyndicateByID(db *sql.DB, id int) (*models.Syndicate, error) {
|
|
row := db.QueryRow(`SELECT id, name, description, owner_id, created_at FROM syndicates WHERE id = ?`, id)
|
|
var s models.Syndicate
|
|
err := row.Scan(&s.ID, &s.Name, &s.Description, &s.OwnerID, &s.CreatedAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &s, nil
|
|
}
|
|
|
|
func IsSyndicateManager(db *sql.DB, syndicateID, userID int) bool {
|
|
var count int
|
|
err := db.QueryRow(`
|
|
SELECT COUNT(*) FROM syndicates
|
|
WHERE id = ? AND owner_id = ?
|
|
`, syndicateID, userID).Scan(&count)
|
|
return err == nil && count > 0
|
|
}
|
|
|
|
func GetSyndicateMembers(db *sql.DB, syndicateID int) []models.SyndicateMember {
|
|
rows, err := db.Query(`
|
|
SELECT m.user_id, u.username, m.joined_at
|
|
FROM syndicate_members m
|
|
JOIN users u ON u.id = m.user_id
|
|
WHERE m.syndicate_id = ?
|
|
`, syndicateID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer rows.Close()
|
|
|
|
var members []models.SyndicateMember
|
|
for rows.Next() {
|
|
var m models.SyndicateMember
|
|
err := rows.Scan(&m.UserID, &m.UserID, &m.JoinedAt)
|
|
if err == nil {
|
|
members = append(members, m)
|
|
}
|
|
}
|
|
return members
|
|
}
|
|
|
|
func IsSyndicateMember(db *sql.DB, syndicateID, userID int) bool {
|
|
var count int
|
|
err := db.QueryRow(`SELECT COUNT(*) FROM syndicate_members WHERE syndicate_id = ? AND user_id = ?`, syndicateID, userID).Scan(&count)
|
|
return err == nil && count > 0
|
|
}
|
|
|
|
func AddMemberToSyndicate(db *sql.DB, syndicateID, userID int) error {
|
|
_, err := db.Exec(`
|
|
INSERT INTO syndicate_members (syndicate_id, user_id, joined_at)
|
|
VALUES (?, ?, CURRENT_TIMESTAMP)
|
|
`, syndicateID, userID)
|
|
return err
|
|
}
|
|
|
|
func GetSyndicateTickets(db *sql.DB, syndicateID int) []models.Ticket {
|
|
rows, err := db.Query(`
|
|
SELECT id, userId, syndicateId, game_type, draw_date, ball1, ball2, ball3, ball4, ball5, ball6,
|
|
bonus1, bonus2, matched_main, matched_bonus, prize_tier, prize_amount, prize_label, is_winner
|
|
FROM my_tickets
|
|
WHERE syndicateId = ?
|
|
ORDER BY draw_date DESC
|
|
`, syndicateID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer rows.Close()
|
|
|
|
var tickets []models.Ticket
|
|
for rows.Next() {
|
|
var t models.Ticket
|
|
err := rows.Scan(
|
|
&t.Id, &t.UserId, &t.SyndicateId, &t.GameType, &t.DrawDate,
|
|
&t.Ball1, &t.Ball2, &t.Ball3, &t.Ball4, &t.Ball5, &t.Ball6,
|
|
&t.Bonus1, &t.Bonus2, &t.MatchedMain, &t.MatchedBonus,
|
|
&t.PrizeTier, &t.PrizeAmount, &t.PrizeLabel, &t.IsWinner,
|
|
)
|
|
if err == nil {
|
|
tickets = append(tickets, t)
|
|
}
|
|
}
|
|
return tickets
|
|
}
|
|
|
|
func InviteUserToSyndicate(db *sql.DB, syndicateID, invitedUserID, senderID int) error {
|
|
_, err := db.Exec(`
|
|
INSERT INTO syndicate_invites (syndicate_id, invited_user_id, sent_by_user_id)
|
|
VALUES (?, ?, ?)
|
|
`, syndicateID, invitedUserID, senderID)
|
|
return err
|
|
}
|
|
|
|
func GetPendingInvites(db *sql.DB, userID int) []models.SyndicateInvite {
|
|
rows, err := db.Query(`
|
|
SELECT id, syndicate_id, invited_user_id, sent_by_user_id, status, created_at
|
|
FROM syndicate_invites
|
|
WHERE invited_user_id = ? AND status = 'pending'
|
|
`, userID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer rows.Close()
|
|
|
|
var invites []models.SyndicateInvite
|
|
for rows.Next() {
|
|
var i models.SyndicateInvite
|
|
rows.Scan(&i.ID, &i.SyndicateID, &i.InvitedUserID, &i.SentByUserID, &i.Status, &i.CreatedAt)
|
|
invites = append(invites, i)
|
|
}
|
|
return invites
|
|
}
|
|
|
|
func UpdateInviteStatus(db *sql.DB, inviteID int, status string) error {
|
|
_, err := db.Exec(`
|
|
UPDATE syndicate_invites
|
|
SET status = ?
|
|
WHERE id = ?
|
|
`, status, inviteID)
|
|
return err
|
|
}
|
|
|
|
func AcceptInvite(db *sql.DB, inviteID, userID int) error {
|
|
var syndicateID int
|
|
err := db.QueryRow(`
|
|
SELECT syndicate_id FROM syndicate_invites
|
|
WHERE id = ? AND invited_user_id = ? AND status = 'pending'
|
|
`, inviteID, userID).Scan(&syndicateID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := UpdateInviteStatus(db, inviteID, "accepted"); err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = db.Exec(`
|
|
INSERT INTO syndicate_members (syndicate_id, user_id, joined_at)
|
|
VALUES (?, ?, CURRENT_TIMESTAMP)
|
|
`, syndicateID, userID)
|
|
return err
|
|
}
|
|
|
|
func CreateSyndicate(db *sql.DB, ownerID int, name, description string) (int64, error) {
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer tx.Rollback()
|
|
|
|
result, err := tx.Exec(`
|
|
INSERT INTO syndicates (name, description, owner_id, created_at)
|
|
VALUES (?, ?, ?, ?)
|
|
`, name, description, ownerID, time.Now())
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to create syndicate: %w", err)
|
|
}
|
|
|
|
syndicateID, err := result.LastInsertId()
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get syndicate ID: %w", err)
|
|
}
|
|
|
|
_, err = tx.Exec(`
|
|
INSERT INTO syndicate_members (syndicate_id, user_id, role, joined_at)
|
|
VALUES (?, ?, 'manager', CURRENT_TIMESTAMP)
|
|
`, syndicateID, ownerID)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to add owner as member: %w", err)
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, fmt.Errorf("commit failed: %w", err)
|
|
}
|
|
|
|
return syndicateID, nil
|
|
}
|
|
|
|
func InviteToSyndicate(db *sql.DB, inviterID, syndicateID int, username string) error {
|
|
var inviteeID int
|
|
err := db.QueryRow(`
|
|
SELECT id FROM users WHERE username = ?
|
|
`, username).Scan(&inviteeID)
|
|
if err == sql.ErrNoRows {
|
|
return fmt.Errorf("user not found")
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
|
|
var count int
|
|
err = db.QueryRow(`
|
|
SELECT COUNT(*) FROM syndicate_members
|
|
WHERE syndicate_id = ? AND user_id = ?
|
|
`, syndicateID, inviteeID).Scan(&count)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count > 0 {
|
|
return fmt.Errorf("user already a member or invited")
|
|
}
|
|
|
|
_, err = db.Exec(`
|
|
INSERT INTO syndicate_members (syndicate_id, user_id, is_manager, status)
|
|
VALUES (?, ?, 0, 'invited')
|
|
`, syndicateID, inviteeID)
|
|
return err
|
|
}
|
|
|
|
func GetInviteTokensForSyndicate(db *sql.DB, syndicateID int) []models.SyndicateInviteToken {
|
|
rows, err := db.Query(`
|
|
SELECT token, invited_by_user_id, accepted_by_user_id, created_at, expires_at, accepted_at
|
|
FROM syndicate_invite_tokens
|
|
WHERE syndicate_id = ?
|
|
ORDER BY created_at DESC
|
|
`, syndicateID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer rows.Close()
|
|
|
|
var tokens []models.SyndicateInviteToken
|
|
for rows.Next() {
|
|
var t models.SyndicateInviteToken
|
|
_ = rows.Scan(
|
|
&t.Token,
|
|
&t.InvitedByUserID,
|
|
&t.AcceptedByUserID,
|
|
&t.CreatedAt,
|
|
&t.ExpiresAt,
|
|
&t.AcceptedAt,
|
|
)
|
|
tokens = append(tokens, t)
|
|
}
|
|
return tokens
|
|
}
|