mirror of
https://github.com/shtorm-7/sing-box-extended.git
synced 2026-05-29 23:46:00 +03:00
2220 lines
46 KiB
Go
2220 lines
46 KiB
Go
package postgresql
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"time"
|
|
|
|
"github.com/golang-migrate/migrate/v4"
|
|
"github.com/huandu/go-sqlbuilder"
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
"github.com/sagernet/sing-box/common/byteformats"
|
|
"github.com/sagernet/sing-box/service/manager/constant"
|
|
)
|
|
|
|
var squadFilters, nodeFilters, userFilters, bandwidthLimiterFilters, connectionLimiterFilters, trafficLimiterFilters, rateLimiterFilters map[string]Filter
|
|
|
|
type PostgreSQLRepository struct {
|
|
db *pgxpool.Pool
|
|
ctx context.Context
|
|
}
|
|
|
|
func NewPostgreSQLRepository(ctx context.Context, dsn string) (*PostgreSQLRepository, error) {
|
|
db, err := sql.Open("postgres", dsn)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer db.Close()
|
|
if err := Migrate(db); err != nil && err != migrate.ErrNoChange {
|
|
return nil, err
|
|
}
|
|
pool, err := pgxpool.New(ctx, dsn)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PostgreSQLRepository{db: pool, ctx: ctx}, nil
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateSquad(squad constant.SquadCreate) (constant.Squad, error) {
|
|
var s constant.Squad
|
|
now := time.Now()
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO squads
|
|
(
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3)
|
|
RETURNING
|
|
id,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
squad.Name,
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&s.ID,
|
|
&s.Name,
|
|
&s.CreatedAt,
|
|
&s.UpdatedAt,
|
|
)
|
|
return s, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetSquads(filters map[string][]string) ([]constant.Squad, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"id",
|
|
"name",
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("squads")
|
|
for k, v := range filters {
|
|
if f, ok := squadFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.Squad
|
|
for rows.Next() {
|
|
var squad constant.Squad
|
|
if err := rows.Scan(
|
|
&squad.ID,
|
|
&squad.Name,
|
|
&squad.CreatedAt,
|
|
&squad.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, squad)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetSquadsCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("squads")
|
|
for k, v := range filters {
|
|
if f, ok := squadFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetSquad(id int) (constant.Squad, error) {
|
|
var s constant.Squad
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
id,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
FROM squads
|
|
WHERE id=$1
|
|
`, id).Scan(
|
|
&s.ID,
|
|
&s.Name,
|
|
&s.CreatedAt,
|
|
&s.UpdatedAt,
|
|
)
|
|
return s, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateSquad(id int, squad constant.SquadUpdate) (constant.Squad, error) {
|
|
var s constant.Squad
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE squads
|
|
SET
|
|
name=$1,
|
|
updated_at=$2
|
|
WHERE id=$3
|
|
RETURNING
|
|
id,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
squad.Name,
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&s.ID,
|
|
&s.Name,
|
|
&s.CreatedAt,
|
|
&s.UpdatedAt,
|
|
)
|
|
return s, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteSquad(id int) (constant.DeletedSquad, error) {
|
|
var result constant.DeletedSquad
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
affectedNodeRows, err := tx.Query(r.ctx, `DELETE FROM node_to_squad WHERE squad_id=$1 RETURNING node_uuid`, id)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
affectedNodeUUIDs := make([]string, 0)
|
|
for affectedNodeRows.Next() {
|
|
var uuid string
|
|
if err = affectedNodeRows.Scan(&uuid); err != nil {
|
|
affectedNodeRows.Close()
|
|
return result, err
|
|
}
|
|
affectedNodeUUIDs = append(affectedNodeUUIDs, uuid)
|
|
}
|
|
affectedNodeRows.Close()
|
|
if err = affectedNodeRows.Err(); err != nil {
|
|
return result, err
|
|
}
|
|
for _, table := range []string{
|
|
"user_to_squad",
|
|
"connection_limiter_to_squad",
|
|
"bandwidth_limiter_to_squad",
|
|
"traffic_limiter_to_squad",
|
|
"rate_limiter_to_squad",
|
|
} {
|
|
if _, err = tx.Exec(r.ctx, `DELETE FROM `+table+` WHERE squad_id=$1`, id); err != nil {
|
|
return result, err
|
|
}
|
|
}
|
|
err = tx.QueryRow(r.ctx, `
|
|
DELETE FROM squads
|
|
WHERE id=$1
|
|
RETURNING
|
|
id,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
`, id).Scan(
|
|
&result.Squad.ID,
|
|
&result.Squad.Name,
|
|
&result.Squad.CreatedAt,
|
|
&result.Squad.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
orphanedNodeRows, err := tx.Query(r.ctx, `
|
|
DELETE FROM nodes
|
|
WHERE NOT EXISTS (SELECT 1 FROM node_to_squad WHERE node_to_squad.node_uuid = nodes.uuid)
|
|
RETURNING uuid
|
|
`)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
orphanedNodeUUIDs := make(map[string]struct{})
|
|
for orphanedNodeRows.Next() {
|
|
var uuid string
|
|
if err = orphanedNodeRows.Scan(&uuid); err != nil {
|
|
orphanedNodeRows.Close()
|
|
return result, err
|
|
}
|
|
orphanedNodeUUIDs[uuid] = struct{}{}
|
|
result.OrphanedNodeUUIDs = append(result.OrphanedNodeUUIDs, uuid)
|
|
}
|
|
orphanedNodeRows.Close()
|
|
if err = orphanedNodeRows.Err(); err != nil {
|
|
return result, err
|
|
}
|
|
for _, uuid := range affectedNodeUUIDs {
|
|
if _, ok := orphanedNodeUUIDs[uuid]; !ok {
|
|
result.SurvivingNodeUUIDs = append(result.SurvivingNodeUUIDs, uuid)
|
|
}
|
|
}
|
|
if _, err = tx.Exec(r.ctx, `
|
|
DELETE FROM users
|
|
WHERE NOT EXISTS (SELECT 1 FROM user_to_squad WHERE user_to_squad.user_id = users.id)
|
|
`); err != nil {
|
|
return result, err
|
|
}
|
|
connRows, err := tx.Query(r.ctx, `
|
|
DELETE FROM connection_limiters
|
|
WHERE NOT EXISTS (SELECT 1 FROM connection_limiter_to_squad WHERE connection_limiter_to_squad.connection_limiter_id = connection_limiters.id)
|
|
RETURNING id
|
|
`)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
for connRows.Next() {
|
|
var lid int
|
|
if err = connRows.Scan(&lid); err != nil {
|
|
connRows.Close()
|
|
return result, err
|
|
}
|
|
result.OrphanedConnectionLimiterIDs = append(result.OrphanedConnectionLimiterIDs, lid)
|
|
}
|
|
connRows.Close()
|
|
if err = connRows.Err(); err != nil {
|
|
return result, err
|
|
}
|
|
if _, err = tx.Exec(r.ctx, `
|
|
DELETE FROM bandwidth_limiters
|
|
WHERE NOT EXISTS (SELECT 1 FROM bandwidth_limiter_to_squad WHERE bandwidth_limiter_to_squad.bandwidth_limiter_id = bandwidth_limiters.id)
|
|
`); err != nil {
|
|
return result, err
|
|
}
|
|
trafficRows, err := tx.Query(r.ctx, `
|
|
DELETE FROM traffic_limiters
|
|
WHERE NOT EXISTS (SELECT 1 FROM traffic_limiter_to_squad WHERE traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id)
|
|
RETURNING id
|
|
`)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
for trafficRows.Next() {
|
|
var lid int
|
|
if err = trafficRows.Scan(&lid); err != nil {
|
|
trafficRows.Close()
|
|
return result, err
|
|
}
|
|
result.OrphanedTrafficLimiterIDs = append(result.OrphanedTrafficLimiterIDs, lid)
|
|
}
|
|
trafficRows.Close()
|
|
if err = trafficRows.Err(); err != nil {
|
|
return result, err
|
|
}
|
|
if _, err = tx.Exec(r.ctx, `
|
|
DELETE FROM rate_limiters
|
|
WHERE NOT EXISTS (SELECT 1 FROM rate_limiter_to_squad WHERE rate_limiter_to_squad.rate_limiter_id = rate_limiters.id)
|
|
`); err != nil {
|
|
return result, err
|
|
}
|
|
if err = tx.Commit(r.ctx); err != nil {
|
|
return result, err
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateNode(node constant.NodeCreate) (constant.Node, error) {
|
|
var n constant.Node
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
now := time.Now()
|
|
err = tx.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO nodes (
|
|
uuid,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING
|
|
uuid,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
node.UUID,
|
|
node.Name,
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&n.UUID,
|
|
&n.Name,
|
|
&n.CreatedAt,
|
|
&n.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
rows := make([][]any, len(node.SquadIDs))
|
|
for i, squadID := range node.SquadIDs {
|
|
rows[i] = []any{node.UUID, squadID}
|
|
}
|
|
_, err = tx.CopyFrom(
|
|
r.ctx,
|
|
pgx.Identifier{"node_to_squad"},
|
|
[]string{"node_uuid", "squad_id"},
|
|
pgx.CopyFromRows(rows),
|
|
)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
err = tx.Commit(r.ctx)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
return n, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetNodes(filters map[string][]string) ([]constant.Node, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"uuid",
|
|
"name",
|
|
`ARRAY(
|
|
SELECT squad_id
|
|
FROM node_to_squad
|
|
WHERE node_to_squad.node_uuid = nodes.uuid
|
|
) as squad_ids`,
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("nodes")
|
|
for key, value := range filters {
|
|
if filter, ok := nodeFilters[key]; ok {
|
|
if err := filter(sb, value); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.Node
|
|
for rows.Next() {
|
|
var n constant.Node
|
|
if err := rows.Scan(
|
|
&n.UUID,
|
|
&n.Name,
|
|
&n.SquadIDs,
|
|
&n.CreatedAt,
|
|
&n.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, n)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetNodesCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("nodes")
|
|
for key, value := range filters {
|
|
if filter, ok := nodeFilters[key]; ok {
|
|
if err := filter(sb, value); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetNode(uuid string) (constant.Node, error) {
|
|
var n constant.Node
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
uuid,
|
|
name,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM node_to_squad
|
|
WHERE node_to_squad.node_uuid = nodes.uuid
|
|
) as squad_ids,
|
|
created_at,
|
|
updated_at
|
|
FROM nodes
|
|
WHERE uuid = $1
|
|
`, uuid).Scan(
|
|
&n.UUID,
|
|
&n.Name,
|
|
&n.SquadIDs,
|
|
&n.CreatedAt,
|
|
&n.UpdatedAt,
|
|
)
|
|
if err != nil && err.Error() == "no rows in result set" {
|
|
return n, constant.ErrNotFound
|
|
}
|
|
return n, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateNode(uuid string, node constant.NodeUpdate) (constant.Node, error) {
|
|
var n constant.Node
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE nodes
|
|
SET
|
|
name = $1,
|
|
updated_at = $2
|
|
WHERE uuid = $3
|
|
RETURNING
|
|
uuid,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
node.Name,
|
|
time.Now(),
|
|
uuid,
|
|
).Scan(
|
|
&n.UUID,
|
|
&n.Name,
|
|
&n.CreatedAt,
|
|
&n.UpdatedAt,
|
|
)
|
|
return n, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteNode(uuid string) (constant.Node, error) {
|
|
var n constant.Node
|
|
err := r.db.QueryRow(r.ctx, `
|
|
DELETE FROM nodes
|
|
WHERE uuid = $1
|
|
RETURNING
|
|
uuid,
|
|
name,
|
|
created_at,
|
|
updated_at
|
|
`, uuid).Scan(
|
|
&n.UUID,
|
|
&n.Name,
|
|
&n.CreatedAt,
|
|
&n.UpdatedAt,
|
|
)
|
|
return n, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateUser(user constant.UserCreate) (constant.User, error) {
|
|
var u constant.User
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return u, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
now := time.Now()
|
|
err = tx.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO users (
|
|
username,
|
|
inbound,
|
|
type,
|
|
uuid,
|
|
password,
|
|
secret,
|
|
flow,
|
|
alter_id,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
RETURNING
|
|
id,
|
|
username,
|
|
inbound,
|
|
type,
|
|
uuid,
|
|
password,
|
|
secret,
|
|
flow,
|
|
alter_id,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
user.Username,
|
|
user.Inbound,
|
|
user.Type,
|
|
user.UUID,
|
|
user.Password,
|
|
user.Secret,
|
|
user.Flow,
|
|
user.AlterID,
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&u.ID,
|
|
&u.Username,
|
|
&u.Inbound,
|
|
&u.Type,
|
|
&u.UUID,
|
|
&u.Password,
|
|
&u.Secret,
|
|
&u.Flow,
|
|
&u.AlterID,
|
|
&u.CreatedAt,
|
|
&u.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return u, err
|
|
}
|
|
rows := make([][]any, len(user.SquadIDs))
|
|
for i, squadID := range user.SquadIDs {
|
|
rows[i] = []any{u.ID, squadID}
|
|
}
|
|
_, err = tx.CopyFrom(
|
|
r.ctx,
|
|
pgx.Identifier{"user_to_squad"},
|
|
[]string{"user_id", "squad_id"},
|
|
pgx.CopyFromRows(rows),
|
|
)
|
|
if err != nil {
|
|
return u, err
|
|
}
|
|
u.SquadIDs = user.SquadIDs
|
|
err = tx.Commit(r.ctx)
|
|
if err != nil {
|
|
return u, err
|
|
}
|
|
return u, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetUsers(filters map[string][]string) ([]constant.User, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"id",
|
|
`ARRAY(
|
|
SELECT squad_id
|
|
FROM user_to_squad
|
|
WHERE user_to_squad.user_id = users.id
|
|
) as squad_ids`,
|
|
"username",
|
|
"inbound",
|
|
"type",
|
|
"uuid",
|
|
"password",
|
|
"secret",
|
|
"flow",
|
|
"alter_id",
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("users")
|
|
for key, value := range filters {
|
|
if filter, ok := userFilters[key]; ok {
|
|
if err := filter(sb, value); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.User
|
|
for rows.Next() {
|
|
var u constant.User
|
|
if err := rows.Scan(
|
|
&u.ID,
|
|
&u.SquadIDs,
|
|
&u.Username,
|
|
&u.Inbound,
|
|
&u.Type,
|
|
&u.UUID,
|
|
&u.Password,
|
|
&u.Secret,
|
|
&u.Flow,
|
|
&u.AlterID,
|
|
&u.CreatedAt,
|
|
&u.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, u)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetUsersCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("users")
|
|
for key, value := range filters {
|
|
if filter, ok := userFilters[key]; ok {
|
|
if err := filter(sb, value); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetUser(id int) (constant.User, error) {
|
|
var u constant.User
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM user_to_squad
|
|
WHERE user_to_squad.user_id = users.id
|
|
) as squad_ids,
|
|
username,
|
|
inbound,
|
|
type,
|
|
uuid,
|
|
password,
|
|
secret,
|
|
flow,
|
|
alter_id,
|
|
created_at,
|
|
updated_at
|
|
FROM users
|
|
WHERE id = $1
|
|
`, id).Scan(
|
|
&u.ID,
|
|
&u.SquadIDs,
|
|
&u.Username,
|
|
&u.Inbound,
|
|
&u.Type,
|
|
&u.UUID,
|
|
&u.Password,
|
|
&u.Secret,
|
|
&u.Flow,
|
|
&u.AlterID,
|
|
&u.CreatedAt,
|
|
&u.UpdatedAt,
|
|
)
|
|
return u, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateUser(id int, user constant.UserUpdate) (constant.User, error) {
|
|
var u constant.User
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE users
|
|
SET
|
|
uuid = $1,
|
|
password = $2,
|
|
secret = $3,
|
|
flow = $4,
|
|
alter_id = $5,
|
|
updated_at = $6
|
|
WHERE id = $7
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM user_to_squad
|
|
WHERE user_to_squad.user_id = users.id
|
|
) as squad_ids,
|
|
username,
|
|
inbound,
|
|
type,
|
|
uuid,
|
|
password,
|
|
secret,
|
|
flow,
|
|
alter_id,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
user.UUID,
|
|
user.Password,
|
|
user.Secret,
|
|
user.Flow,
|
|
user.AlterID,
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&u.ID,
|
|
&u.SquadIDs,
|
|
&u.Username,
|
|
&u.Inbound,
|
|
&u.Type,
|
|
&u.UUID,
|
|
&u.Password,
|
|
&u.Secret,
|
|
&u.Flow,
|
|
&u.AlterID,
|
|
&u.CreatedAt,
|
|
&u.UpdatedAt,
|
|
)
|
|
return u, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteUser(id int) (constant.User, error) {
|
|
var u constant.User
|
|
err := r.db.QueryRow(r.ctx, `
|
|
DELETE FROM users
|
|
WHERE id = $1
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM user_to_squad
|
|
WHERE user_to_squad.user_id = users.id
|
|
) as squad_ids,
|
|
username,
|
|
inbound,
|
|
type,
|
|
uuid,
|
|
password,
|
|
secret,
|
|
flow,
|
|
alter_id,
|
|
created_at,
|
|
updated_at
|
|
`, id).Scan(
|
|
&u.ID,
|
|
&u.SquadIDs,
|
|
&u.Username,
|
|
&u.Inbound,
|
|
&u.Type,
|
|
&u.UUID,
|
|
&u.Password,
|
|
&u.Secret,
|
|
&u.Flow,
|
|
&u.AlterID,
|
|
&u.CreatedAt,
|
|
&u.UpdatedAt,
|
|
)
|
|
return u, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateConnectionLimiter(limiter constant.ConnectionLimiterCreate) (constant.ConnectionLimiter, error) {
|
|
var cl constant.ConnectionLimiter
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return cl, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
now := time.Now()
|
|
err = tx.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO connection_limiters
|
|
(
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
lock_type,
|
|
count,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
|
RETURNING
|
|
id,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
lock_type,
|
|
count,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.ConnectionType,
|
|
limiter.LockType,
|
|
limiter.Count,
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&cl.ID,
|
|
&cl.Username,
|
|
&cl.Outbound,
|
|
&cl.Strategy,
|
|
&cl.ConnectionType,
|
|
&cl.LockType,
|
|
&cl.Count,
|
|
&cl.CreatedAt,
|
|
&cl.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return cl, err
|
|
}
|
|
rows := make([][]any, len(limiter.SquadIDs))
|
|
for i, squadID := range limiter.SquadIDs {
|
|
rows[i] = []any{cl.ID, squadID}
|
|
}
|
|
_, err = tx.CopyFrom(
|
|
r.ctx,
|
|
pgx.Identifier{"connection_limiter_to_squad"},
|
|
[]string{"connection_limiter_id", "squad_id"},
|
|
pgx.CopyFromRows(rows),
|
|
)
|
|
if err != nil {
|
|
return cl, err
|
|
}
|
|
cl.SquadIDs = limiter.SquadIDs
|
|
err = tx.Commit(r.ctx)
|
|
if err != nil {
|
|
return cl, err
|
|
}
|
|
return cl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetConnectionLimiters(filters map[string][]string) ([]constant.ConnectionLimiter, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"id",
|
|
`ARRAY(
|
|
SELECT squad_id
|
|
FROM connection_limiter_to_squad
|
|
WHERE connection_limiter_to_squad.connection_limiter_id = connection_limiters.id
|
|
) as squad_ids`,
|
|
"username",
|
|
"outbound",
|
|
"strategy",
|
|
"connection_type",
|
|
"lock_type",
|
|
"count",
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("connection_limiters")
|
|
for k, v := range filters {
|
|
if f, ok := connectionLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.ConnectionLimiter
|
|
for rows.Next() {
|
|
var cl constant.ConnectionLimiter
|
|
if err := rows.Scan(
|
|
&cl.ID,
|
|
&cl.SquadIDs,
|
|
&cl.Username,
|
|
&cl.Outbound,
|
|
&cl.Strategy,
|
|
&cl.ConnectionType,
|
|
&cl.LockType,
|
|
&cl.Count,
|
|
&cl.CreatedAt,
|
|
&cl.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, cl)
|
|
}
|
|
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetConnectionLimitersCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("connection_limiters")
|
|
|
|
for k, v := range filters {
|
|
if f, ok := connectionLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetConnectionLimiter(id int) (constant.ConnectionLimiter, error) {
|
|
var cl constant.ConnectionLimiter
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM connection_limiter_to_squad
|
|
WHERE connection_limiter_to_squad.connection_limiter_id = connection_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
lock_type,
|
|
count,
|
|
created_at,
|
|
updated_at
|
|
FROM connection_limiters
|
|
WHERE id=$1
|
|
`, id).Scan(
|
|
&cl.ID,
|
|
&cl.SquadIDs,
|
|
&cl.Username,
|
|
&cl.Outbound,
|
|
&cl.Strategy,
|
|
&cl.ConnectionType,
|
|
&cl.LockType,
|
|
&cl.Count,
|
|
&cl.CreatedAt,
|
|
&cl.UpdatedAt,
|
|
)
|
|
return cl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateConnectionLimiter(id int, limiter constant.ConnectionLimiterUpdate) (constant.ConnectionLimiter, error) {
|
|
var cl constant.ConnectionLimiter
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE connection_limiters
|
|
SET
|
|
strategy=$1,
|
|
connection_type=$2,
|
|
lock_type=$3,
|
|
count=$4,
|
|
updated_at=$5
|
|
WHERE id=$6
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM connection_limiter_to_squad
|
|
WHERE connection_limiter_to_squad.connection_limiter_id = connection_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
lock_type,
|
|
count,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Strategy,
|
|
limiter.ConnectionType,
|
|
limiter.LockType,
|
|
limiter.Count,
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&cl.ID,
|
|
&cl.SquadIDs,
|
|
&cl.Username,
|
|
&cl.Outbound,
|
|
&cl.Strategy,
|
|
&cl.ConnectionType,
|
|
&cl.LockType,
|
|
&cl.Count,
|
|
&cl.CreatedAt,
|
|
&cl.UpdatedAt,
|
|
)
|
|
return cl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteConnectionLimiter(id int) (constant.ConnectionLimiter, error) {
|
|
var cl constant.ConnectionLimiter
|
|
err := r.db.QueryRow(r.ctx, `
|
|
DELETE FROM connection_limiters
|
|
WHERE id=$1
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM connection_limiter_to_squad
|
|
WHERE connection_limiter_to_squad.connection_limiter_id = connection_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
lock_type,
|
|
count,
|
|
created_at,
|
|
updated_at
|
|
`, id).Scan(
|
|
&cl.ID,
|
|
&cl.SquadIDs,
|
|
&cl.Username,
|
|
&cl.Outbound,
|
|
&cl.Strategy,
|
|
&cl.ConnectionType,
|
|
&cl.LockType,
|
|
&cl.Count,
|
|
&cl.CreatedAt,
|
|
&cl.UpdatedAt,
|
|
)
|
|
return cl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateBandwidthLimiter(limiter constant.BandwidthLimiterCreate) (constant.BandwidthLimiter, error) {
|
|
var bl constant.BandwidthLimiter
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
bytesSpeed, err := json.Marshal(limiter.Speed)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
raw := &byteformats.NetworkBytesCompat{}
|
|
if err = raw.UnmarshalJSON(bytesSpeed); err != nil {
|
|
return bl, err
|
|
}
|
|
flowKeysJSON, err := marshalStringSlice(limiter.FlowKeys)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
var flowKeys stringSliceJSON
|
|
now := time.Now()
|
|
err = tx.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO bandwidth_limiters
|
|
(
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
mode,
|
|
flow_keys,
|
|
speed,
|
|
raw_speed,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
RETURNING
|
|
id,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
mode,
|
|
flow_keys,
|
|
speed,
|
|
raw_speed,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.ConnectionType,
|
|
limiter.Mode,
|
|
flowKeysJSON,
|
|
limiter.Speed,
|
|
raw.Value(),
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&bl.ID,
|
|
&bl.Username,
|
|
&bl.Outbound,
|
|
&bl.Strategy,
|
|
&bl.ConnectionType,
|
|
&bl.Mode,
|
|
&flowKeys,
|
|
&bl.Speed,
|
|
&bl.RawSpeed,
|
|
&bl.CreatedAt,
|
|
&bl.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
bl.FlowKeys = []string(flowKeys)
|
|
rows := make([][]any, len(limiter.SquadIDs))
|
|
for i, squadID := range limiter.SquadIDs {
|
|
rows[i] = []any{bl.ID, squadID}
|
|
}
|
|
_, err = tx.CopyFrom(
|
|
r.ctx,
|
|
pgx.Identifier{"bandwidth_limiter_to_squad"},
|
|
[]string{"bandwidth_limiter_id", "squad_id"},
|
|
pgx.CopyFromRows(rows),
|
|
)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
bl.SquadIDs = limiter.SquadIDs
|
|
err = tx.Commit(r.ctx)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
return bl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetBandwidthLimiters(filters map[string][]string) ([]constant.BandwidthLimiter, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"id",
|
|
`ARRAY(
|
|
SELECT squad_id
|
|
FROM bandwidth_limiter_to_squad
|
|
WHERE bandwidth_limiter_to_squad.bandwidth_limiter_id = bandwidth_limiters.id
|
|
) as squad_ids`,
|
|
"username",
|
|
"outbound",
|
|
"strategy",
|
|
"connection_type",
|
|
"mode",
|
|
"flow_keys",
|
|
"speed",
|
|
"raw_speed",
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("bandwidth_limiters")
|
|
|
|
for k, v := range filters {
|
|
if f, ok := bandwidthLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.BandwidthLimiter
|
|
for rows.Next() {
|
|
var bl constant.BandwidthLimiter
|
|
var flowKeys stringSliceJSON
|
|
if err := rows.Scan(
|
|
&bl.ID,
|
|
&bl.SquadIDs,
|
|
&bl.Username,
|
|
&bl.Outbound,
|
|
&bl.Strategy,
|
|
&bl.ConnectionType,
|
|
&bl.Mode,
|
|
&flowKeys,
|
|
&bl.Speed,
|
|
&bl.RawSpeed,
|
|
&bl.CreatedAt,
|
|
&bl.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
bl.FlowKeys = []string(flowKeys)
|
|
result = append(result, bl)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetBandwidthLimitersCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("bandwidth_limiters")
|
|
for k, v := range filters {
|
|
if f, ok := bandwidthLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetBandwidthLimiter(id int) (constant.BandwidthLimiter, error) {
|
|
var bl constant.BandwidthLimiter
|
|
var flowKeys stringSliceJSON
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM bandwidth_limiter_to_squad
|
|
WHERE bandwidth_limiter_to_squad.bandwidth_limiter_id = bandwidth_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
mode,
|
|
flow_keys,
|
|
speed,
|
|
raw_speed,
|
|
created_at,
|
|
updated_at
|
|
FROM bandwidth_limiters
|
|
WHERE id=$1
|
|
`, id).Scan(
|
|
&bl.ID,
|
|
&bl.SquadIDs,
|
|
&bl.Username,
|
|
&bl.Outbound,
|
|
&bl.Strategy,
|
|
&bl.ConnectionType,
|
|
&bl.Mode,
|
|
&flowKeys,
|
|
&bl.Speed,
|
|
&bl.RawSpeed,
|
|
&bl.CreatedAt,
|
|
&bl.UpdatedAt,
|
|
)
|
|
bl.FlowKeys = []string(flowKeys)
|
|
return bl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateBandwidthLimiter(id int, limiter constant.BandwidthLimiterUpdate) (constant.BandwidthLimiter, error) {
|
|
var bl constant.BandwidthLimiter
|
|
var flowKeys stringSliceJSON
|
|
bytesSpeed, err := json.Marshal(limiter.Speed)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
raw := &byteformats.NetworkBytesCompat{}
|
|
if err = raw.UnmarshalJSON(bytesSpeed); err != nil {
|
|
return bl, err
|
|
}
|
|
flowKeysJSON, err := marshalStringSlice(limiter.FlowKeys)
|
|
if err != nil {
|
|
return bl, err
|
|
}
|
|
err = r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE bandwidth_limiters
|
|
SET
|
|
username=$1,
|
|
outbound=$2,
|
|
strategy=$3,
|
|
connection_type=$4,
|
|
mode=$5,
|
|
flow_keys=$6,
|
|
speed=$7,
|
|
raw_speed=$8,
|
|
updated_at=$9
|
|
WHERE id=$10
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM bandwidth_limiter_to_squad
|
|
WHERE bandwidth_limiter_to_squad.bandwidth_limiter_id = bandwidth_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
mode,
|
|
flow_keys,
|
|
speed,
|
|
raw_speed,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.ConnectionType,
|
|
limiter.Mode,
|
|
flowKeysJSON,
|
|
limiter.Speed,
|
|
raw.Value(),
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&bl.ID,
|
|
&bl.SquadIDs,
|
|
&bl.Username,
|
|
&bl.Outbound,
|
|
&bl.Strategy,
|
|
&bl.ConnectionType,
|
|
&bl.Mode,
|
|
&flowKeys,
|
|
&bl.Speed,
|
|
&bl.RawSpeed,
|
|
&bl.CreatedAt,
|
|
&bl.UpdatedAt,
|
|
)
|
|
bl.FlowKeys = []string(flowKeys)
|
|
return bl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteBandwidthLimiter(id int) (constant.BandwidthLimiter, error) {
|
|
var bl constant.BandwidthLimiter
|
|
var flowKeys stringSliceJSON
|
|
err := r.db.QueryRow(r.ctx, `
|
|
DELETE FROM bandwidth_limiters
|
|
WHERE id=$1
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM bandwidth_limiter_to_squad
|
|
WHERE bandwidth_limiter_to_squad.bandwidth_limiter_id = bandwidth_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
mode,
|
|
flow_keys,
|
|
speed,
|
|
raw_speed,
|
|
created_at,
|
|
updated_at
|
|
`, id).Scan(
|
|
&bl.ID,
|
|
&bl.SquadIDs,
|
|
&bl.Username,
|
|
&bl.Outbound,
|
|
&bl.Strategy,
|
|
&bl.ConnectionType,
|
|
&bl.Mode,
|
|
&flowKeys,
|
|
&bl.Speed,
|
|
&bl.RawSpeed,
|
|
&bl.CreatedAt,
|
|
&bl.UpdatedAt,
|
|
)
|
|
bl.FlowKeys = []string(flowKeys)
|
|
return bl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateTrafficLimiter(limiter constant.TrafficLimiterCreate) (constant.TrafficLimiter, error) {
|
|
var tl constant.TrafficLimiter
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return tl, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
bytesQuota, err := json.Marshal(limiter.Quota)
|
|
if err != nil {
|
|
return tl, err
|
|
}
|
|
rawQuota := &byteformats.NetworkBytesCompat{}
|
|
if err = rawQuota.UnmarshalJSON(bytesQuota); err != nil {
|
|
return tl, err
|
|
}
|
|
now := time.Now()
|
|
err = tx.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO traffic_limiters
|
|
(
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
mode,
|
|
quota,
|
|
raw_quota,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
|
RETURNING
|
|
id,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
mode,
|
|
raw_used,
|
|
quota,
|
|
raw_quota,
|
|
CASE WHEN raw_quota = 0 THEN 0 ELSE LEAST(100, FLOOR(raw_used * 100.0 / raw_quota)::int) END AS usage,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.Mode,
|
|
limiter.Quota,
|
|
rawQuota.Value(),
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&tl.ID,
|
|
&tl.Username,
|
|
&tl.Outbound,
|
|
&tl.Strategy,
|
|
&tl.Mode,
|
|
&tl.RawUsed,
|
|
&tl.Quota,
|
|
&tl.RawQuota,
|
|
&tl.Usage,
|
|
&tl.CreatedAt,
|
|
&tl.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return tl, err
|
|
}
|
|
rows := make([][]any, len(limiter.SquadIDs))
|
|
for i, squadID := range limiter.SquadIDs {
|
|
rows[i] = []any{tl.ID, squadID}
|
|
}
|
|
_, err = tx.CopyFrom(
|
|
r.ctx,
|
|
pgx.Identifier{"traffic_limiter_to_squad"},
|
|
[]string{"traffic_limiter_id", "squad_id"},
|
|
pgx.CopyFromRows(rows),
|
|
)
|
|
if err != nil {
|
|
return tl, err
|
|
}
|
|
tl.SquadIDs = limiter.SquadIDs
|
|
err = tx.Commit(r.ctx)
|
|
if err != nil {
|
|
return tl, err
|
|
}
|
|
return tl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetTrafficLimiters(filters map[string][]string) ([]constant.TrafficLimiter, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"id",
|
|
`ARRAY(
|
|
SELECT squad_id
|
|
FROM traffic_limiter_to_squad
|
|
WHERE traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id
|
|
) as squad_ids`,
|
|
"username",
|
|
"outbound",
|
|
"strategy",
|
|
"mode",
|
|
"raw_used",
|
|
"quota",
|
|
"raw_quota",
|
|
"CASE WHEN raw_quota = 0 THEN 0 ELSE LEAST(100, FLOOR(raw_used * 100.0 / raw_quota)::int) END AS usage",
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("traffic_limiters")
|
|
|
|
for k, v := range filters {
|
|
if f, ok := trafficLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.TrafficLimiter
|
|
for rows.Next() {
|
|
var tl constant.TrafficLimiter
|
|
if err := rows.Scan(
|
|
&tl.ID,
|
|
&tl.SquadIDs,
|
|
&tl.Username,
|
|
&tl.Outbound,
|
|
&tl.Strategy,
|
|
&tl.Mode,
|
|
&tl.RawUsed,
|
|
&tl.Quota,
|
|
&tl.RawQuota,
|
|
&tl.Usage,
|
|
&tl.CreatedAt,
|
|
&tl.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, tl)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetTrafficLimitersCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("traffic_limiters")
|
|
for k, v := range filters {
|
|
if f, ok := trafficLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetTrafficLimiter(id int) (constant.TrafficLimiter, error) {
|
|
var tl constant.TrafficLimiter
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM traffic_limiter_to_squad
|
|
WHERE traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
mode,
|
|
raw_used,
|
|
quota,
|
|
raw_quota,
|
|
CASE WHEN raw_quota = 0 THEN 0 ELSE LEAST(100, FLOOR(raw_used * 100.0 / raw_quota)::int) END AS usage,
|
|
created_at,
|
|
updated_at
|
|
FROM traffic_limiters
|
|
WHERE id=$1
|
|
`, id).Scan(
|
|
&tl.ID,
|
|
&tl.SquadIDs,
|
|
&tl.Username,
|
|
&tl.Outbound,
|
|
&tl.Strategy,
|
|
&tl.Mode,
|
|
&tl.RawUsed,
|
|
&tl.Quota,
|
|
&tl.RawQuota,
|
|
&tl.Usage,
|
|
&tl.CreatedAt,
|
|
&tl.UpdatedAt,
|
|
)
|
|
return tl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateTrafficLimiter(id int, limiter constant.TrafficLimiterUpdate) (constant.TrafficLimiter, error) {
|
|
var tl constant.TrafficLimiter
|
|
bytesQuota, err := json.Marshal(limiter.Quota)
|
|
if err != nil {
|
|
return tl, err
|
|
}
|
|
rawQuota := &byteformats.NetworkBytesCompat{}
|
|
if err = rawQuota.UnmarshalJSON(bytesQuota); err != nil {
|
|
return tl, err
|
|
}
|
|
err = r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE traffic_limiters
|
|
SET
|
|
username=$1,
|
|
outbound=$2,
|
|
strategy=$3,
|
|
mode=$4,
|
|
quota=$5,
|
|
raw_quota=$6,
|
|
updated_at=$7
|
|
WHERE id=$8
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM traffic_limiter_to_squad
|
|
WHERE traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
mode,
|
|
raw_used,
|
|
quota,
|
|
raw_quota,
|
|
CASE WHEN raw_quota = 0 THEN 0 ELSE LEAST(100, FLOOR(raw_used * 100.0 / raw_quota)::int) END AS usage,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.Mode,
|
|
limiter.Quota,
|
|
rawQuota.Value(),
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&tl.ID,
|
|
&tl.SquadIDs,
|
|
&tl.Username,
|
|
&tl.Outbound,
|
|
&tl.Strategy,
|
|
&tl.Mode,
|
|
&tl.RawUsed,
|
|
&tl.Quota,
|
|
&tl.RawQuota,
|
|
&tl.Usage,
|
|
&tl.CreatedAt,
|
|
&tl.UpdatedAt,
|
|
)
|
|
return tl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateTrafficLimiterUsed(id int, current uint64) (constant.TrafficLimiter, error) {
|
|
var tl constant.TrafficLimiter
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE traffic_limiters
|
|
SET
|
|
raw_used=$1,
|
|
updated_at=$2
|
|
WHERE id=$3
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM traffic_limiter_to_squad
|
|
WHERE traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
mode,
|
|
raw_used,
|
|
quota,
|
|
raw_quota,
|
|
CASE WHEN raw_quota = 0 THEN 0 ELSE LEAST(100, FLOOR(raw_used * 100.0 / raw_quota)::int) END AS usage,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
current,
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&tl.ID,
|
|
&tl.SquadIDs,
|
|
&tl.Username,
|
|
&tl.Outbound,
|
|
&tl.Strategy,
|
|
&tl.Mode,
|
|
&tl.RawUsed,
|
|
&tl.Quota,
|
|
&tl.RawQuota,
|
|
&tl.Usage,
|
|
&tl.CreatedAt,
|
|
&tl.UpdatedAt,
|
|
)
|
|
return tl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteTrafficLimiter(id int) (constant.TrafficLimiter, error) {
|
|
var tl constant.TrafficLimiter
|
|
err := r.db.QueryRow(r.ctx, `
|
|
DELETE FROM traffic_limiters
|
|
WHERE id=$1
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM traffic_limiter_to_squad
|
|
WHERE traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
mode,
|
|
raw_used,
|
|
quota,
|
|
raw_quota,
|
|
CASE WHEN raw_quota = 0 THEN 0 ELSE LEAST(100, FLOOR(raw_used * 100.0 / raw_quota)::int) END AS usage,
|
|
created_at,
|
|
updated_at
|
|
`, id).Scan(
|
|
&tl.ID,
|
|
&tl.SquadIDs,
|
|
&tl.Username,
|
|
&tl.Outbound,
|
|
&tl.Strategy,
|
|
&tl.Mode,
|
|
&tl.RawUsed,
|
|
&tl.Quota,
|
|
&tl.RawQuota,
|
|
&tl.Usage,
|
|
&tl.CreatedAt,
|
|
&tl.UpdatedAt,
|
|
)
|
|
return tl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) CreateRateLimiter(limiter constant.RateLimiterCreate) (constant.RateLimiter, error) {
|
|
var rl constant.RateLimiter
|
|
tx, err := r.db.Begin(r.ctx)
|
|
if err != nil {
|
|
return rl, err
|
|
}
|
|
defer tx.Rollback(r.ctx)
|
|
now := time.Now()
|
|
err = tx.QueryRow(
|
|
r.ctx, `
|
|
INSERT INTO rate_limiters
|
|
(
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
count,
|
|
interval,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
|
RETURNING
|
|
id,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
count,
|
|
interval,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.ConnectionType,
|
|
limiter.Count,
|
|
limiter.Interval,
|
|
now,
|
|
now,
|
|
).Scan(
|
|
&rl.ID,
|
|
&rl.Username,
|
|
&rl.Outbound,
|
|
&rl.Strategy,
|
|
&rl.ConnectionType,
|
|
&rl.Count,
|
|
&rl.Interval,
|
|
&rl.CreatedAt,
|
|
&rl.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return rl, err
|
|
}
|
|
rows := make([][]any, len(limiter.SquadIDs))
|
|
for i, squadID := range limiter.SquadIDs {
|
|
rows[i] = []any{rl.ID, squadID}
|
|
}
|
|
_, err = tx.CopyFrom(
|
|
r.ctx,
|
|
pgx.Identifier{"rate_limiter_to_squad"},
|
|
[]string{"rate_limiter_id", "squad_id"},
|
|
pgx.CopyFromRows(rows),
|
|
)
|
|
if err != nil {
|
|
return rl, err
|
|
}
|
|
rl.SquadIDs = limiter.SquadIDs
|
|
err = tx.Commit(r.ctx)
|
|
if err != nil {
|
|
return rl, err
|
|
}
|
|
return rl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetRateLimiters(filters map[string][]string) ([]constant.RateLimiter, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"id",
|
|
`ARRAY(
|
|
SELECT squad_id
|
|
FROM rate_limiter_to_squad
|
|
WHERE rate_limiter_to_squad.rate_limiter_id = rate_limiters.id
|
|
) as squad_ids`,
|
|
"username",
|
|
"outbound",
|
|
"strategy",
|
|
"connection_type",
|
|
"count",
|
|
"interval",
|
|
"created_at",
|
|
"updated_at",
|
|
).
|
|
From("rate_limiters")
|
|
|
|
for k, v := range filters {
|
|
if f, ok := rateLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
rows, err := r.db.Query(r.ctx, sql, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var result []constant.RateLimiter
|
|
for rows.Next() {
|
|
var rl constant.RateLimiter
|
|
if err := rows.Scan(
|
|
&rl.ID,
|
|
&rl.SquadIDs,
|
|
&rl.Username,
|
|
&rl.Outbound,
|
|
&rl.Strategy,
|
|
&rl.ConnectionType,
|
|
&rl.Count,
|
|
&rl.Interval,
|
|
&rl.CreatedAt,
|
|
&rl.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, rl)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetRateLimitersCount(filters map[string][]string) (int, error) {
|
|
sb := sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select("COUNT(*)").
|
|
From("rate_limiters")
|
|
for k, v := range filters {
|
|
if f, ok := rateLimiterFilters[k]; ok {
|
|
if err := f(sb, v); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
sql, args := sb.Build()
|
|
var count int
|
|
err := r.db.QueryRow(r.ctx, sql, args...).Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) GetRateLimiter(id int) (constant.RateLimiter, error) {
|
|
var rl constant.RateLimiter
|
|
err := r.db.QueryRow(r.ctx, `
|
|
SELECT
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM rate_limiter_to_squad
|
|
WHERE rate_limiter_to_squad.rate_limiter_id = rate_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
count,
|
|
interval,
|
|
created_at,
|
|
updated_at
|
|
FROM rate_limiters
|
|
WHERE id=$1
|
|
`, id).Scan(
|
|
&rl.ID,
|
|
&rl.SquadIDs,
|
|
&rl.Username,
|
|
&rl.Outbound,
|
|
&rl.Strategy,
|
|
&rl.ConnectionType,
|
|
&rl.Count,
|
|
&rl.Interval,
|
|
&rl.CreatedAt,
|
|
&rl.UpdatedAt,
|
|
)
|
|
return rl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) UpdateRateLimiter(id int, limiter constant.RateLimiterUpdate) (constant.RateLimiter, error) {
|
|
var rl constant.RateLimiter
|
|
err := r.db.QueryRow(
|
|
r.ctx, `
|
|
UPDATE rate_limiters
|
|
SET
|
|
username=$1,
|
|
outbound=$2,
|
|
strategy=$3,
|
|
connection_type=$4,
|
|
count=$5,
|
|
interval=$6,
|
|
updated_at=$7
|
|
WHERE id=$8
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM rate_limiter_to_squad
|
|
WHERE rate_limiter_to_squad.rate_limiter_id = rate_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
count,
|
|
interval,
|
|
created_at,
|
|
updated_at
|
|
`,
|
|
limiter.Username,
|
|
limiter.Outbound,
|
|
limiter.Strategy,
|
|
limiter.ConnectionType,
|
|
limiter.Count,
|
|
limiter.Interval,
|
|
time.Now(),
|
|
id,
|
|
).Scan(
|
|
&rl.ID,
|
|
&rl.SquadIDs,
|
|
&rl.Username,
|
|
&rl.Outbound,
|
|
&rl.Strategy,
|
|
&rl.ConnectionType,
|
|
&rl.Count,
|
|
&rl.Interval,
|
|
&rl.CreatedAt,
|
|
&rl.UpdatedAt,
|
|
)
|
|
return rl, err
|
|
}
|
|
|
|
func (r *PostgreSQLRepository) DeleteRateLimiter(id int) (constant.RateLimiter, error) {
|
|
var rl constant.RateLimiter
|
|
err := r.db.QueryRow(r.ctx, `
|
|
DELETE FROM rate_limiters
|
|
WHERE id=$1
|
|
RETURNING
|
|
id,
|
|
ARRAY(
|
|
SELECT squad_id
|
|
FROM rate_limiter_to_squad
|
|
WHERE rate_limiter_to_squad.rate_limiter_id = rate_limiters.id
|
|
) as squad_ids,
|
|
username,
|
|
outbound,
|
|
strategy,
|
|
connection_type,
|
|
count,
|
|
interval,
|
|
created_at,
|
|
updated_at
|
|
`, id).Scan(
|
|
&rl.ID,
|
|
&rl.SquadIDs,
|
|
&rl.Username,
|
|
&rl.Outbound,
|
|
&rl.Strategy,
|
|
&rl.ConnectionType,
|
|
&rl.Count,
|
|
&rl.Interval,
|
|
&rl.CreatedAt,
|
|
&rl.UpdatedAt,
|
|
)
|
|
return rl, err
|
|
}
|
|
|
|
func init() {
|
|
squadFilters = map[string]Filter{
|
|
"id": EqualFilter("id"),
|
|
"id_in": InFilter("id"),
|
|
"pk": EqualFilter("id"),
|
|
"name": EqualFilter("name"),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": SortAscFilter(),
|
|
"sort_desc": SortDescFilter(),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
nodeFilters = map[string]Filter{
|
|
"uuid": EqualFilter("uuid"),
|
|
"pk": EqualFilter("uuid"),
|
|
"name": EqualFilter("name"),
|
|
"squad_id_in": ExistsAndWhereInFilter(
|
|
sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"squad_id",
|
|
).
|
|
Where(
|
|
"node_to_squad.node_uuid = nodes.uuid",
|
|
).
|
|
From(
|
|
"node_to_squad",
|
|
),
|
|
"node_to_squad.squad_id",
|
|
),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": SortAscFilter(),
|
|
"sort_desc": SortDescFilter(),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
userFilters = map[string]Filter{
|
|
"id": EqualFilter("id"),
|
|
"pk": EqualFilter("id"),
|
|
"squad_id_in": ExistsAndWhereInFilter(
|
|
sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"squad_id",
|
|
).
|
|
Where(
|
|
"user_to_squad.user_id = users.id",
|
|
).
|
|
From(
|
|
"user_to_squad",
|
|
),
|
|
"user_to_squad.squad_id",
|
|
),
|
|
"username": EqualFilter("username"),
|
|
"inbound": EqualFilter("inbound"),
|
|
"type": EqualFilter("type"),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": SortAscFilter(),
|
|
"sort_desc": SortDescFilter(),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
connectionLimiterFilters = map[string]Filter{
|
|
"id": EqualFilter("id"),
|
|
"pk": EqualFilter("id"),
|
|
"squad_id_in": ExistsAndWhereInFilter(
|
|
sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"squad_id",
|
|
).
|
|
Where(
|
|
"connection_limiter_to_squad.connection_limiter_id = connection_limiters.id",
|
|
).
|
|
From(
|
|
"connection_limiter_to_squad",
|
|
),
|
|
"connection_limiter_to_squad.squad_id",
|
|
),
|
|
"strategy": EqualFilter("strategy"),
|
|
"username": EqualFilter("username"),
|
|
"outbound": EqualFilter("outbound"),
|
|
"connection_type": EqualFilter("connection_type"),
|
|
"lock_type": EqualFilter("lock_type"),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": SortAscFilter(),
|
|
"sort_desc": SortDescFilter(),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
bandwidthLimiterFilters = map[string]Filter{
|
|
"id": EqualFilter("id"),
|
|
"pk": EqualFilter("id"),
|
|
"squad_id_in": ExistsAndWhereInFilter(
|
|
sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"squad_id",
|
|
).
|
|
Where(
|
|
"bandwidth_limiter_to_squad.bandwidth_limiter_id = bandwidth_limiters.id",
|
|
).
|
|
From(
|
|
"bandwidth_limiter_to_squad",
|
|
),
|
|
"bandwidth_limiter_to_squad.squad_id",
|
|
),
|
|
"strategy": EqualFilter("strategy"),
|
|
"mode": EqualFilter("mode"),
|
|
"type": EqualFilter("type"),
|
|
"username": EqualFilter("username"),
|
|
"down_start": SpeedGreaterEqualThanFilter("raw_down"),
|
|
"down_end": SpeedLessEqualThanFilter("raw_down"),
|
|
"up_start": SpeedGreaterEqualThanFilter("raw_up"),
|
|
"up_end": SpeedLessEqualThanFilter("raw_up"),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": ReplacedSortAscFilter(map[string]string{"down": "raw_down", "up": "raw_up"}),
|
|
"sort_desc": ReplacedSortDescFilter(map[string]string{"down": "raw_down", "up": "raw_up"}),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
trafficLimiterFilters = map[string]Filter{
|
|
"id": EqualFilter("id"),
|
|
"pk": EqualFilter("id"),
|
|
"squad_id_in": ExistsAndWhereInFilter(
|
|
sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"squad_id",
|
|
).
|
|
Where(
|
|
"traffic_limiter_to_squad.traffic_limiter_id = traffic_limiters.id",
|
|
).
|
|
From(
|
|
"traffic_limiter_to_squad",
|
|
),
|
|
"traffic_limiter_to_squad.squad_id",
|
|
),
|
|
"username": EqualFilter("username"),
|
|
"outbound": EqualFilter("outbound"),
|
|
"strategy": EqualFilter("strategy"),
|
|
"mode": EqualFilter("mode"),
|
|
"used_start": SpeedGreaterEqualThanFilter("raw_used"),
|
|
"used_end": SpeedLessEqualThanFilter("raw_used"),
|
|
"quota_start": SpeedGreaterEqualThanFilter("raw_quota"),
|
|
"quota_end": SpeedLessEqualThanFilter("raw_quota"),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": ReplacedSortAscFilter(map[string]string{"used": "raw_used", "quota": "raw_quota"}),
|
|
"sort_desc": ReplacedSortDescFilter(map[string]string{"used": "raw_used", "quota": "raw_quota"}),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
rateLimiterFilters = map[string]Filter{
|
|
"id": EqualFilter("id"),
|
|
"pk": EqualFilter("id"),
|
|
"squad_id_in": ExistsAndWhereInFilter(
|
|
sqlbuilder.PostgreSQL.NewSelectBuilder().
|
|
Select(
|
|
"squad_id",
|
|
).
|
|
Where(
|
|
"rate_limiter_to_squad.rate_limiter_id = rate_limiters.id",
|
|
).
|
|
From(
|
|
"rate_limiter_to_squad",
|
|
),
|
|
"rate_limiter_to_squad.squad_id",
|
|
),
|
|
"strategy": EqualFilter("strategy"),
|
|
"username": EqualFilter("username"),
|
|
"outbound": EqualFilter("outbound"),
|
|
"connection_type": EqualFilter("connection_type"),
|
|
"interval": EqualFilter("interval"),
|
|
"count_start": GreaterEqualThanFilter("count"),
|
|
"count_end": LessEqualThanFilter("count"),
|
|
"created_at_start": GreaterThanFilter("created_at"),
|
|
"created_at_end": LessThanFilter("created_at"),
|
|
"updated_at_start": GreaterThanFilter("updated_at"),
|
|
"updated_at_end": LessThanFilter("updated_at"),
|
|
"sort_asc": SortAscFilter(),
|
|
"sort_desc": SortDescFilter(),
|
|
"offset": OffsetFilter(),
|
|
"limit": LimitFilter(),
|
|
}
|
|
}
|