package persist
import (
"context"
"github.com/jackc/pgx/v5/pgtype"
)
const findGitHubRepositories = `-- name: FindGitHubRepositories :many
SELECT
owner,
name
FROM
github_repository
`
func (q *Queries) FindGitHubRepositories(ctx context.Context) ([]GithubRepository, error) {
rows, err := q.db.Query(ctx, findGitHubRepositories)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GithubRepository
for rows.Next() {
var i GithubRepository
if err := rows.Scan(&i.Owner, &i.Name); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getActiveGitHubProjects = `-- name: GetActiveGitHubProjects :many
SELECT
org,
number,
title,
description,
url,
closed,
category,
category_reasoning,
updated_at
FROM
github_project
WHERE
org = $1
AND closed = false
ORDER BY
number
`
func (q *Queries) GetActiveGitHubProjects(ctx context.Context, org string) ([]GithubProject, error) {
rows, err := q.db.Query(ctx, getActiveGitHubProjects, org)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GithubProject
for rows.Next() {
var i GithubProject
if err := rows.Scan(
&i.Org,
&i.Number,
&i.Title,
&i.Description,
&i.Url,
&i.Closed,
&i.Category,
&i.CategoryReasoning,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getAllGitHubProjects = `-- name: GetAllGitHubProjects :many
SELECT
org,
number,
title,
description,
url,
closed,
category,
category_reasoning,
updated_at
FROM
github_project
WHERE
org = $1
ORDER BY
number
`
func (q *Queries) GetAllGitHubProjects(ctx context.Context, org string) ([]GithubProject, error) {
rows, err := q.db.Query(ctx, getAllGitHubProjects, org)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GithubProject
for rows.Next() {
var i GithubProject
if err := rows.Scan(
&i.Org,
&i.Number,
&i.Title,
&i.Description,
&i.Url,
&i.Closed,
&i.Category,
&i.CategoryReasoning,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getGitHubProject = `-- name: GetGitHubProject :one
SELECT
org,
number,
title,
description,
url,
closed,
category,
category_reasoning,
updated_at
FROM
github_project
WHERE
org = $1
AND number = $2
`
type GetGitHubProjectParams struct {
Org string
Number int32
}
func (q *Queries) GetGitHubProject(ctx context.Context, arg GetGitHubProjectParams) (GithubProject, error) {
row := q.db.QueryRow(ctx, getGitHubProject, arg.Org, arg.Number)
var i GithubProject
err := row.Scan(
&i.Org,
&i.Number,
&i.Title,
&i.Description,
&i.Url,
&i.Closed,
&i.Category,
&i.CategoryReasoning,
&i.UpdatedAt,
)
return i, err
}
const getGitHubProjectsByCategory = `-- name: GetGitHubProjectsByCategory :many
SELECT
org,
number,
title,
description,
url,
closed,
category,
category_reasoning,
updated_at
FROM
github_project
WHERE
org = $1
AND closed = false
AND category = $2
ORDER BY
number
`
type GetGitHubProjectsByCategoryParams struct {
Org string
Category pgtype.Text
}
func (q *Queries) GetGitHubProjectsByCategory(ctx context.Context, arg GetGitHubProjectsByCategoryParams) ([]GithubProject, error) {
rows, err := q.db.Query(ctx, getGitHubProjectsByCategory, arg.Org, arg.Category)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GithubProject
for rows.Next() {
var i GithubProject
if err := rows.Scan(
&i.Org,
&i.Number,
&i.Title,
&i.Description,
&i.Url,
&i.Closed,
&i.Category,
&i.CategoryReasoning,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getUnclassifiedGitHubProjects = `-- name: GetUnclassifiedGitHubProjects :many
SELECT
org,
number,
title,
description,
url,
closed,
category,
category_reasoning,
updated_at
FROM
github_project
WHERE
org = $1
AND closed = false
AND category IS NULL
ORDER BY
number
`
func (q *Queries) GetUnclassifiedGitHubProjects(ctx context.Context, org string) ([]GithubProject, error) {
rows, err := q.db.Query(ctx, getUnclassifiedGitHubProjects, org)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GithubProject
for rows.Next() {
var i GithubProject
if err := rows.Scan(
&i.Org,
&i.Number,
&i.Title,
&i.Description,
&i.Url,
&i.Closed,
&i.Category,
&i.CategoryReasoning,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const upsertGitHubProject = `-- name: UpsertGitHubProject :exec
INSERT INTO
github_project (
org,
number,
title,
description,
url,
closed,
category,
category_reasoning,
updated_at
)
VALUES
($1, $2, $3, $4, $5, $6, $7, $8, NOW()) ON CONFLICT (org, number) DO
UPDATE
SET
title = EXCLUDED.title,
description = EXCLUDED.description,
url = EXCLUDED.url,
closed = EXCLUDED.closed,
category = COALESCE(
EXCLUDED.category,
github_project.category
),
category_reasoning = COALESCE(
EXCLUDED.category_reasoning,
github_project.category_reasoning
),
updated_at = NOW()
`
type UpsertGitHubProjectParams struct {
Org string
Number int32
Title string
Description pgtype.Text
Url string
Closed bool
Category pgtype.Text
CategoryReasoning pgtype.Text
}
func (q *Queries) UpsertGitHubProject(ctx context.Context, arg UpsertGitHubProjectParams) error {
_, err := q.db.Exec(ctx, upsertGitHubProject,
arg.Org,
arg.Number,
arg.Title,
arg.Description,
arg.Url,
arg.Closed,
arg.Category,
arg.CategoryReasoning,
)
return err
}