admin.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: admin.sql

package database

import (
	"context"
)

const getAdminStats = `-- name: GetAdminStats :one
SELECT
    CAST((SELECT COUNT(*) FROM users WHERE deleted_at IS NULL) AS INTEGER) as user_count,
    CAST(((SELECT COUNT(*) FROM discussion_posts WHERE deleted_at IS NULL) + (SELECT COUNT(*) FROM discussion_comments WHERE deleted_at IS NULL)) AS INTEGER) as post_count,
    CAST((SELECT COUNT(*) FROM archive WHERE deleted_at IS NULL) AS INTEGER) as archive_count,
    CAST((SELECT COUNT(*) FROM events WHERE deleted_at IS NULL) AS INTEGER) as event_count,
    CAST((SELECT COUNT(DISTINCT name) FROM modules WHERE deleted_at IS NULL) AS INTEGER) as module_count,
    CAST((SELECT COUNT(*) FROM programs WHERE deleted_at IS NULL) AS INTEGER) as program_count,
    CAST((SELECT COUNT(*) FROM activities WHERE deleted_at IS NULL) AS INTEGER) as activity_count
`

type GetAdminStatsRow struct {
	UserCount     int64 `json:"user_count"`
	PostCount     int64 `json:"post_count"`
	ArchiveCount  int64 `json:"archive_count"`
	EventCount    int64 `json:"event_count"`
	ModuleCount   int64 `json:"module_count"`
	ProgramCount  int64 `json:"program_count"`
	ActivityCount int64 `json:"activity_count"`
}

func (q *Queries) GetAdminStats(ctx context.Context) (GetAdminStatsRow, error) {
	row := q.db.QueryRowContext(ctx, getAdminStats)
	var i GetAdminStatsRow
	err := row.Scan(
		&i.UserCount,
		&i.PostCount,
		&i.ArchiveCount,
		&i.EventCount,
		&i.ModuleCount,
		&i.ProgramCount,
		&i.ActivityCount,
	)
	return i, err
}

const getDailyActivityTrend = `-- name: GetDailyActivityTrend :many
SELECT 
    date(created_at) as date,
    COUNT(*) as count
FROM activities
WHERE created_at >= date('now', '-90 days') AND deleted_at IS NULL
GROUP BY date
ORDER BY date ASC
`

type GetDailyActivityTrendRow struct {
	Date  interface{} `json:"date"`
	Count int64       `json:"count"`
}

func (q *Queries) GetDailyActivityTrend(ctx context.Context) ([]GetDailyActivityTrendRow, error) {
	rows, err := q.db.QueryContext(ctx, getDailyActivityTrend)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetDailyActivityTrendRow
	for rows.Next() {
		var i GetDailyActivityTrendRow
		if err := rows.Scan(&i.Date, &i.Count); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDailyDiscussionGrowth = `-- name: GetDailyDiscussionGrowth :many
SELECT 
    date,
    CAST(COALESCE(SUM(count), 0) AS INTEGER) as count
FROM (
    SELECT date(created_at) as date, COUNT(*) as count 
    FROM discussion_posts 
    WHERE created_at >= date('now', '-90 days') AND deleted_at IS NULL
    GROUP BY date
    UNION ALL
    SELECT date(created_at) as date, COUNT(*) as count 
    FROM discussion_comments 
    WHERE created_at >= date('now', '-90 days') AND deleted_at IS NULL
    GROUP BY date
)
GROUP BY date
ORDER BY date ASC
`

type GetDailyDiscussionGrowthRow struct {
	Date  interface{} `json:"date"`
	Count int64       `json:"count"`
}

func (q *Queries) GetDailyDiscussionGrowth(ctx context.Context) ([]GetDailyDiscussionGrowthRow, error) {
	rows, err := q.db.QueryContext(ctx, getDailyDiscussionGrowth)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetDailyDiscussionGrowthRow
	for rows.Next() {
		var i GetDailyDiscussionGrowthRow
		if err := rows.Scan(&i.Date, &i.Count); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDailyExamGrowth = `-- name: GetDailyExamGrowth :many
SELECT 
    date(created_at) as date,
    COUNT(*) as count
FROM archive
WHERE created_at >= date('now', '-90 days') AND deleted_at IS NULL
GROUP BY date
ORDER BY date ASC
`

type GetDailyExamGrowthRow struct {
	Date  interface{} `json:"date"`
	Count int64       `json:"count"`
}

func (q *Queries) GetDailyExamGrowth(ctx context.Context) ([]GetDailyExamGrowthRow, error) {
	rows, err := q.db.QueryContext(ctx, getDailyExamGrowth)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetDailyExamGrowthRow
	for rows.Next() {
		var i GetDailyExamGrowthRow
		if err := rows.Scan(&i.Date, &i.Count); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDailyModuleGrowth = `-- name: GetDailyModuleGrowth :many
SELECT 
    first_seen as date,
    COUNT(*) as count
FROM (
    SELECT date(MIN(created_at)) as first_seen
    FROM modules
    WHERE deleted_at IS NULL
    GROUP BY name
)
WHERE first_seen >= date('now', '-90 days')
GROUP BY first_seen
ORDER BY first_seen ASC
`

type GetDailyModuleGrowthRow struct {
	Date  interface{} `json:"date"`
	Count int64       `json:"count"`
}

func (q *Queries) GetDailyModuleGrowth(ctx context.Context) ([]GetDailyModuleGrowthRow, error) {
	rows, err := q.db.QueryContext(ctx, getDailyModuleGrowth)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetDailyModuleGrowthRow
	for rows.Next() {
		var i GetDailyModuleGrowthRow
		if err := rows.Scan(&i.Date, &i.Count); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDailyProgramGrowth = `-- name: GetDailyProgramGrowth :many
SELECT 
    date(created_at) as date,
    COUNT(*) as count
FROM programs
WHERE created_at >= date('now', '-90 days') AND deleted_at IS NULL
GROUP BY date
ORDER BY date ASC
`

type GetDailyProgramGrowthRow struct {
	Date  interface{} `json:"date"`
	Count int64       `json:"count"`
}

func (q *Queries) GetDailyProgramGrowth(ctx context.Context) ([]GetDailyProgramGrowthRow, error) {
	rows, err := q.db.QueryContext(ctx, getDailyProgramGrowth)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetDailyProgramGrowthRow
	for rows.Next() {
		var i GetDailyProgramGrowthRow
		if err := rows.Scan(&i.Date, &i.Count); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDailyUserGrowth = `-- name: GetDailyUserGrowth :many
SELECT 
    date(created_at) as date,
    COUNT(*) as count
FROM users
WHERE created_at >= date('now', '-90 days') AND deleted_at IS NULL
GROUP BY date
ORDER BY date ASC
`

type GetDailyUserGrowthRow struct {
	Date  interface{} `json:"date"`
	Count int64       `json:"count"`
}

func (q *Queries) GetDailyUserGrowth(ctx context.Context) ([]GetDailyUserGrowthRow, error) {
	rows, err := q.db.QueryContext(ctx, getDailyUserGrowth)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetDailyUserGrowthRow
	for rows.Next() {
		var i GetDailyUserGrowthRow
		if err := rows.Scan(&i.Date, &i.Count); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserProgramDistribution = `-- name: GetUserProgramDistribution :many
SELECT 
    p.name as program_name,
    COUNT(u.id) as user_count
FROM programs p
JOIN users u ON u.program_id = p.id
WHERE u.deleted_at IS NULL AND p.deleted_at IS NULL
GROUP BY p.name
`

type GetUserProgramDistributionRow struct {
	ProgramName string `json:"program_name"`
	UserCount   int64  `json:"user_count"`
}

func (q *Queries) GetUserProgramDistribution(ctx context.Context) ([]GetUserProgramDistributionRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserProgramDistribution)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUserProgramDistributionRow
	for rows.Next() {
		var i GetUserProgramDistributionRow
		if err := rows.Scan(&i.ProgramName, &i.UserCount); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}