246 lines
6.6 KiB
Go
246 lines
6.6 KiB
Go
package db
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"log/slog"
|
|
)
|
|
|
|
type BotAccessRequest struct {
|
|
db *sql.DB
|
|
log *slog.Logger
|
|
ID int64 `json:"id"`
|
|
TgbID int64 `json:"tgb_id"`
|
|
BotName string `json:"bot_name"`
|
|
BotID int64 `json:"bot_id"`
|
|
Created int64 `json:"edited"`
|
|
}
|
|
|
|
type BotBannedAccess struct {
|
|
db *sql.DB
|
|
log *slog.Logger
|
|
ID int64 `json:"id"`
|
|
TgbID int64 `json:"tgb_id"`
|
|
BotName string `json:"bot_name"`
|
|
Until int64 `json:"until"`
|
|
Created int64 `json:"edited"`
|
|
}
|
|
|
|
func NewBotAccessRequest(db *sql.DB, log *slog.Logger) *BotAccessRequest {
|
|
return &BotAccessRequest{
|
|
db: db,
|
|
log: log,
|
|
}
|
|
}
|
|
|
|
func NewBotBannedAccess(db *sql.DB, log *slog.Logger) *BotBannedAccess {
|
|
return &BotBannedAccess{
|
|
db: db,
|
|
log: log,
|
|
}
|
|
}
|
|
|
|
func (bar *BotAccessRequest) Add(ctx context.Context, tgbID int64, botName string) (bool, error) {
|
|
|
|
stmt, err := bar.db.PrepareContext(ctx,
|
|
`
|
|
INSERT INTO bot_access_requests
|
|
(tgb_id, bot_id, created)
|
|
VALUES(?,(SELECT id FROM bots WHERE bot_name = ?),strftime('%s', 'now'));`)
|
|
|
|
if err != nil {
|
|
bar.log.Error("prepare stmt add bot access request", "error", err)
|
|
return false, err
|
|
}
|
|
defer stmt.Close()
|
|
_, err = stmt.ExecContext(ctx, tgbID, botName)
|
|
if err != nil {
|
|
bar.log.Error("exec add bot access requests", "error", err)
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// Get
|
|
// Get access request pending for bots
|
|
func (bar *BotAccessRequest) Get(ctx context.Context, tgbID int64) ([]*BotAccessRequest, error) {
|
|
stmt, err := bar.db.PrepareContext(ctx,
|
|
`SELECT bar.id, b.bot_name, bar.created FROM bot_access_requests AS bar
|
|
JOIN bots AS b ON bar.bot_id = b.id
|
|
WHERE bar.tgb_id = ?;`)
|
|
if err != nil {
|
|
bar.log.Error("prepare stmt getBots", "error", err)
|
|
return nil, err
|
|
}
|
|
defer stmt.Close()
|
|
rows, err := stmt.QueryContext(ctx, tgbID)
|
|
if err != nil {
|
|
bar.log.Error("query get bot_access_request", "error", err)
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
bl := []*BotAccessRequest{}
|
|
for rows.Next() {
|
|
ba := &BotAccessRequest{}
|
|
err := rows.Scan(&ba.ID, &ba.BotName, &ba.Created)
|
|
if err != nil {
|
|
bar.log.Error("scanning get bots_access_requests", "error", err)
|
|
return nil, err
|
|
}
|
|
bl = append(bl, ba)
|
|
|
|
}
|
|
return bl, nil
|
|
}
|
|
|
|
// GetAll
|
|
// GetAll access request pending for bots
|
|
func (bar *BotAccessRequest) GetAll(ctx context.Context, botName string) ([]*BotAccessRequest, error) {
|
|
stmt, err := bar.db.PrepareContext(ctx,
|
|
`SELECT bar.id, b.bot_name, bar.tgb_id, bar.created FROM bot_access_requests AS bar
|
|
JOIN bots AS b ON bar.bot_id = b.id
|
|
WHERE b.bot_name = ?;`)
|
|
if err != nil {
|
|
bar.log.Error("prepare stmt getBots", "error", err)
|
|
return nil, err
|
|
}
|
|
defer stmt.Close()
|
|
rows, err := stmt.QueryContext(ctx, botName)
|
|
if err != nil {
|
|
bar.log.Error("query get bot_access_request", "error", err)
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
bl := []*BotAccessRequest{}
|
|
for rows.Next() {
|
|
ba := &BotAccessRequest{}
|
|
err := rows.Scan(&ba.ID, &ba.BotName, &ba.TgbID, &ba.Created)
|
|
if err != nil {
|
|
bar.log.Error("scanning get bots_access_requests", "error", err)
|
|
return nil, err
|
|
}
|
|
bl = append(bl, ba)
|
|
|
|
}
|
|
return bl, nil
|
|
}
|
|
|
|
func (bar BotAccessRequest) Delete(ctx context.Context, tgbID int64, botName string) (bool, error) {
|
|
stmt, err := bar.db.PrepareContext(ctx,
|
|
`
|
|
DELETE FROM bot_access_requests as bar
|
|
WHERE bar.bot_id = (SELECT id FROM bots WHERE bot_name = ?) AND bar.tgb_id = ?
|
|
`)
|
|
if err != nil {
|
|
bar.log.Error("prepare stmt delete", "error", err)
|
|
return false, err
|
|
}
|
|
defer stmt.Close()
|
|
_, err = stmt.ExecContext(ctx, botName, tgbID)
|
|
if err != nil {
|
|
bar.log.Error("exec delete", "error", err)
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (bba *BotBannedAccess) Add(ctx context.Context, tgbID, until int64, botName string) (bool, error) {
|
|
|
|
stmt, err := bba.db.PrepareContext(ctx,
|
|
`
|
|
INSERT INTO banned_bot_access
|
|
(tgb_id, until, bot_id, created)
|
|
VALUES(?,?,(SELECT id FROM bots WHERE bot_name = ?),strftime('%s', 'now'));`)
|
|
|
|
if err != nil {
|
|
bba.log.Error("prepare stmt add bot banned access", "error", err)
|
|
return false, err
|
|
}
|
|
defer stmt.Close()
|
|
_, err = stmt.ExecContext(ctx, tgbID, until, botName)
|
|
if err != nil {
|
|
bba.log.Error("exec add bot banned Access", "error", err)
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (bba *BotBannedAccess) Get(ctx context.Context, tgbID int64) ([]*BotBannedAccess, error) {
|
|
stmt, err := bba.db.PrepareContext(ctx,
|
|
`SELECT bba.id, b.bot_name, bba.until, bba.created FROM banned_bot_access AS bba
|
|
JOIN bots AS b ON bba.bot_id = b.id
|
|
WHERE bba.tgb_id = ?;`)
|
|
if err != nil {
|
|
bba.log.Error("prepare stmt bots banned access", "error", err)
|
|
return nil, err
|
|
}
|
|
defer stmt.Close()
|
|
rows, err := stmt.QueryContext(ctx, tgbID)
|
|
if err != nil {
|
|
bba.log.Error("query get bot banned access", "error", err)
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
bl := []*BotBannedAccess{}
|
|
for rows.Next() {
|
|
ba := &BotBannedAccess{}
|
|
err := rows.Scan(&ba.ID, &ba.BotName, &ba.Until, &ba.Created)
|
|
if err != nil {
|
|
bba.log.Error("scanning get bots banned access", "error", err)
|
|
return nil, err
|
|
}
|
|
bl = append(bl, ba)
|
|
|
|
}
|
|
return bl, nil
|
|
}
|
|
|
|
func (bba *BotBannedAccess) GetAll(ctx context.Context, botName string) ([]*BotBannedAccess, error) {
|
|
stmt, err := bba.db.PrepareContext(ctx,
|
|
`SELECT bba.id, b.bot_name, bba.tgb_id, bba.until, bba.created FROM banned_bot_access AS bba
|
|
JOIN bots AS b ON bba.bot_id = b.id
|
|
WHERE b.bot_name = ?;`)
|
|
if err != nil {
|
|
bba.log.Error("prepare stmt bots banned access", "error", err)
|
|
return nil, err
|
|
}
|
|
defer stmt.Close()
|
|
rows, err := stmt.QueryContext(ctx, botName)
|
|
if err != nil {
|
|
bba.log.Error("query get bot banned access", "error", err)
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
bl := []*BotBannedAccess{}
|
|
for rows.Next() {
|
|
ba := &BotBannedAccess{}
|
|
err := rows.Scan(&ba.ID, &ba.BotName, &ba.TgbID, &ba.Until, &ba.Created)
|
|
if err != nil {
|
|
bba.log.Error("scanning get bots banned access", "error", err)
|
|
return nil, err
|
|
}
|
|
bl = append(bl, ba)
|
|
|
|
}
|
|
return bl, nil
|
|
}
|
|
|
|
func (bba *BotBannedAccess) Delete(ctx context.Context, tgbID int64, botName string) (bool, error) {
|
|
stmt, err := bba.db.PrepareContext(ctx,
|
|
`
|
|
DELETE FROM banned_bot_access as bar
|
|
WHERE bar.bot_id = (SELECT id FROM bots WHERE bot_name = ?) AND bar.tgb_id = ?
|
|
`)
|
|
if err != nil {
|
|
bba.log.Error("prepare stmt delete bot banned access", "error", err)
|
|
return false, err
|
|
}
|
|
defer stmt.Close()
|
|
_, err = stmt.ExecContext(ctx, botName, tgbID)
|
|
if err != nil {
|
|
bba.log.Error("exec delete bot banned access", "error", err)
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|