member-console/internal/integrations/discourse/store/user_links.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: user_links.sql

package discourse

import (
	"context"
)

const createUserLink = `-- name: CreateUserLink :one
INSERT INTO discourse.user_links (person_id, discourse_user_id, discourse_username, linked_via)
VALUES ($1, $2, $3, $4)
RETURNING person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at
`

type CreateUserLinkParams struct {
	PersonID          string `json:"person_id"`
	DiscourseUserID   int64  `json:"discourse_user_id"`
	DiscourseUsername string `json:"discourse_username"`
	LinkedVia         string `json:"linked_via"`
}

func (q *Queries) CreateUserLink(ctx context.Context, arg CreateUserLinkParams) (UserLink, error) {
	row := q.db.QueryRowContext(ctx, createUserLink,
		arg.PersonID,
		arg.DiscourseUserID,
		arg.DiscourseUsername,
		arg.LinkedVia,
	)
	var i UserLink
	err := row.Scan(
		&i.PersonID,
		&i.DiscourseUserID,
		&i.DiscourseUsername,
		&i.LinkedVia,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteUserLinkByPersonID = `-- name: DeleteUserLinkByPersonID :execrows
DELETE FROM discourse.user_links
WHERE person_id = $1
`

func (q *Queries) DeleteUserLinkByPersonID(ctx context.Context, personID string) (int64, error) {
	result, err := q.db.ExecContext(ctx, deleteUserLinkByPersonID, personID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const getUserLinkByDiscourseUserID = `-- name: GetUserLinkByDiscourseUserID :one
SELECT person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at FROM discourse.user_links
WHERE discourse_user_id = $1
`

func (q *Queries) GetUserLinkByDiscourseUserID(ctx context.Context, discourseUserID int64) (UserLink, error) {
	row := q.db.QueryRowContext(ctx, getUserLinkByDiscourseUserID, discourseUserID)
	var i UserLink
	err := row.Scan(
		&i.PersonID,
		&i.DiscourseUserID,
		&i.DiscourseUsername,
		&i.LinkedVia,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getUserLinkByPersonID = `-- name: GetUserLinkByPersonID :one
SELECT person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at FROM discourse.user_links
WHERE person_id = $1
`

func (q *Queries) GetUserLinkByPersonID(ctx context.Context, personID string) (UserLink, error) {
	row := q.db.QueryRowContext(ctx, getUserLinkByPersonID, personID)
	var i UserLink
	err := row.Scan(
		&i.PersonID,
		&i.DiscourseUserID,
		&i.DiscourseUsername,
		&i.LinkedVia,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listConflictedUserLinks = `-- name: ListConflictedUserLinks :many
SELECT person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at FROM discourse.user_links
WHERE status = 'conflict'
ORDER BY discourse_username ASC
`

func (q *Queries) ListConflictedUserLinks(ctx context.Context) ([]UserLink, error) {
	rows, err := q.db.QueryContext(ctx, listConflictedUserLinks)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []UserLink{}
	for rows.Next() {
		var i UserLink
		if err := rows.Scan(
			&i.PersonID,
			&i.DiscourseUserID,
			&i.DiscourseUsername,
			&i.LinkedVia,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 listUserLinks = `-- name: ListUserLinks :many
SELECT person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at FROM discourse.user_links
ORDER BY discourse_username ASC
`

func (q *Queries) ListUserLinks(ctx context.Context) ([]UserLink, error) {
	rows, err := q.db.QueryContext(ctx, listUserLinks)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []UserLink{}
	for rows.Next() {
		var i UserLink
		if err := rows.Scan(
			&i.PersonID,
			&i.DiscourseUserID,
			&i.DiscourseUsername,
			&i.LinkedVia,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 setUserLinkConflict = `-- name: SetUserLinkConflict :one
UPDATE discourse.user_links
SET status = 'conflict'
WHERE person_id = $1
RETURNING person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at
`

func (q *Queries) SetUserLinkConflict(ctx context.Context, personID string) (UserLink, error) {
	row := q.db.QueryRowContext(ctx, setUserLinkConflict, personID)
	var i UserLink
	err := row.Scan(
		&i.PersonID,
		&i.DiscourseUserID,
		&i.DiscourseUsername,
		&i.LinkedVia,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const setUserLinkOrphaned = `-- name: SetUserLinkOrphaned :one
UPDATE discourse.user_links
SET status = 'orphaned'
WHERE person_id = $1
RETURNING person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at
`

// Quarantine: the linked Discourse user no longer resolves on the forum.
// Orphaned links leave the convergence desired set (see migration 00003).
func (q *Queries) SetUserLinkOrphaned(ctx context.Context, personID string) (UserLink, error) {
	row := q.db.QueryRowContext(ctx, setUserLinkOrphaned, personID)
	var i UserLink
	err := row.Scan(
		&i.PersonID,
		&i.DiscourseUserID,
		&i.DiscourseUsername,
		&i.LinkedVia,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const updateUserLinkUsername = `-- name: UpdateUserLinkUsername :one
UPDATE discourse.user_links
SET discourse_username = $2
WHERE person_id = $1
RETURNING person_id, discourse_user_id, discourse_username, linked_via, status, created_at, updated_at
`

type UpdateUserLinkUsernameParams struct {
	PersonID          string `json:"person_id"`
	DiscourseUsername string `json:"discourse_username"`
}

// Self-heal: forum-side rename detected — the id-keyed admin record is
// authoritative for the username, which is only a delivery address.
func (q *Queries) UpdateUserLinkUsername(ctx context.Context, arg UpdateUserLinkUsernameParams) (UserLink, error) {
	row := q.db.QueryRowContext(ctx, updateUserLinkUsername, arg.PersonID, arg.DiscourseUsername)
	var i UserLink
	err := row.Scan(
		&i.PersonID,
		&i.DiscourseUserID,
		&i.DiscourseUsername,
		&i.LinkedVia,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}