mails.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.26.0
// source: mails.sql

package queries

import (
	"context"
	"time"
)

const createMail = `-- name: CreateMail :one
INSERT INTO mails (
    body,
    my_character_id,
    from_id,
    is_read,
    mail_id,
    subject,
    timestamp
)
VALUES (
    ?, ?, ?, ?, ?, ?, ?
)
RETURNING id, body, my_character_id, from_id, is_read, mail_id, subject, timestamp
`

type CreateMailParams struct {
	Body          string
	MyCharacterID int64
	FromID        int64
	IsRead        bool
	MailID        int64
	Subject       string
	Timestamp     time.Time
}

func (q *Queries) CreateMail(ctx context.Context, arg CreateMailParams) (Mail, error) {
	row := q.db.QueryRowContext(ctx, createMail,
		arg.Body,
		arg.MyCharacterID,
		arg.FromID,
		arg.IsRead,
		arg.MailID,
		arg.Subject,
		arg.Timestamp,
	)
	var i Mail
	err := row.Scan(
		&i.ID,
		&i.Body,
		&i.MyCharacterID,
		&i.FromID,
		&i.IsRead,
		&i.MailID,
		&i.Subject,
		&i.Timestamp,
	)
	return i, err
}

const createMailMailLabel = `-- name: CreateMailMailLabel :exec
INSERT INTO mail_mail_labels (
    mail_label_id,
    mail_id
)
VALUES (?, ?)
`

type CreateMailMailLabelParams struct {
	MailLabelID int64
	MailID      int64
}

func (q *Queries) CreateMailMailLabel(ctx context.Context, arg CreateMailMailLabelParams) error {
	_, err := q.db.ExecContext(ctx, createMailMailLabel, arg.MailLabelID, arg.MailID)
	return err
}

const createMailRecipient = `-- name: CreateMailRecipient :exec
INSERT INTO mail_recipients (
    mail_id,
    eve_entity_id
)
VALUES (?, ?)
`

type CreateMailRecipientParams struct {
	MailID      int64
	EveEntityID int64
}

func (q *Queries) CreateMailRecipient(ctx context.Context, arg CreateMailRecipientParams) error {
	_, err := q.db.ExecContext(ctx, createMailRecipient, arg.MailID, arg.EveEntityID)
	return err
}

const deleteMail = `-- name: DeleteMail :exec
DELETE FROM mails
WHERE mails.my_character_id = ?
AND mails.mail_id = ?
`

type DeleteMailParams struct {
	MyCharacterID int64
	MailID        int64
}

func (q *Queries) DeleteMail(ctx context.Context, arg DeleteMailParams) error {
	_, err := q.db.ExecContext(ctx, deleteMail, arg.MyCharacterID, arg.MailID)
	return err
}

const deleteMailMailLabels = `-- name: DeleteMailMailLabels :exec
DELETE FROM mail_mail_labels
WHERE mail_mail_labels.mail_id = ?
`

func (q *Queries) DeleteMailMailLabels(ctx context.Context, mailID int64) error {
	_, err := q.db.ExecContext(ctx, deleteMailMailLabels, mailID)
	return err
}

const getMail = `-- name: GetMail :one
SELECT mails.id, mails.body, mails.my_character_id, mails.from_id, mails.is_read, mails.mail_id, mails.subject, mails.timestamp, eve_entities.id, eve_entities.category, eve_entities.name
FROM mails
JOIN eve_entities ON eve_entities.id = mails.from_id
WHERE my_character_id = ?
AND mail_id = ?
`

type GetMailParams struct {
	MyCharacterID int64
	MailID        int64
}

type GetMailRow struct {
	Mail      Mail
	EveEntity EveEntity
}

func (q *Queries) GetMail(ctx context.Context, arg GetMailParams) (GetMailRow, error) {
	row := q.db.QueryRowContext(ctx, getMail, arg.MyCharacterID, arg.MailID)
	var i GetMailRow
	err := row.Scan(
		&i.Mail.ID,
		&i.Mail.Body,
		&i.Mail.MyCharacterID,
		&i.Mail.FromID,
		&i.Mail.IsRead,
		&i.Mail.MailID,
		&i.Mail.Subject,
		&i.Mail.Timestamp,
		&i.EveEntity.ID,
		&i.EveEntity.Category,
		&i.EveEntity.Name,
	)
	return i, err
}

const getMailLabelUnreadCounts = `-- name: GetMailLabelUnreadCounts :many
SELECT label_id, COUNT(mails.id) AS unread_count_2
FROM mail_labels
JOIN mail_mail_labels ON mail_mail_labels.mail_label_id = mail_labels.id
JOIN mails ON mails.id = mail_mail_labels.mail_id
WHERE mail_labels.my_character_id = ?
AND is_read IS FALSE
GROUP BY label_id
`

type GetMailLabelUnreadCountsRow struct {
	LabelID      int64
	UnreadCount2 int64
}

func (q *Queries) GetMailLabelUnreadCounts(ctx context.Context, myCharacterID int64) ([]GetMailLabelUnreadCountsRow, error) {
	rows, err := q.db.QueryContext(ctx, getMailLabelUnreadCounts, myCharacterID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetMailLabelUnreadCountsRow
	for rows.Next() {
		var i GetMailLabelUnreadCountsRow
		if err := rows.Scan(&i.LabelID, &i.UnreadCount2); 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 getMailLabels = `-- name: GetMailLabels :many
SELECT mail_labels.id, mail_labels.my_character_id, mail_labels.color, mail_labels.label_id, mail_labels.name, mail_labels.unread_count
FROM mail_labels
JOIN mail_mail_labels ON mail_mail_labels.mail_label_id = mail_labels.id
WHERE mail_id = ?
`

func (q *Queries) GetMailLabels(ctx context.Context, mailID int64) ([]MailLabel, error) {
	rows, err := q.db.QueryContext(ctx, getMailLabels, mailID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []MailLabel
	for rows.Next() {
		var i MailLabel
		if err := rows.Scan(
			&i.ID,
			&i.MyCharacterID,
			&i.Color,
			&i.LabelID,
			&i.Name,
			&i.UnreadCount,
		); 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 getMailListUnreadCounts = `-- name: GetMailListUnreadCounts :many
SELECT eve_entities.id AS list_id, COUNT(mails.id) as unread_count_2
FROM mails
JOIN mail_recipients ON mail_recipients.mail_id = mails.id
JOIN eve_entities ON eve_entities.id = mail_recipients.eve_entity_id
WHERE my_character_id = ?
AND eve_entities.category = "mail_list"
AND mails.is_read IS FALSE
GROUP BY eve_entities.id
`

type GetMailListUnreadCountsRow struct {
	ListID       int64
	UnreadCount2 int64
}

func (q *Queries) GetMailListUnreadCounts(ctx context.Context, myCharacterID int64) ([]GetMailListUnreadCountsRow, error) {
	rows, err := q.db.QueryContext(ctx, getMailListUnreadCounts, myCharacterID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetMailListUnreadCountsRow
	for rows.Next() {
		var i GetMailListUnreadCountsRow
		if err := rows.Scan(&i.ListID, &i.UnreadCount2); 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 getMailRecipients = `-- name: GetMailRecipients :many
SELECT eve_entities.id, eve_entities.category, eve_entities.name
FROM eve_entities
JOIN mail_recipients ON mail_recipients.eve_entity_id = eve_entities.id
WHERE mail_id = ?
`

func (q *Queries) GetMailRecipients(ctx context.Context, mailID int64) ([]EveEntity, error) {
	rows, err := q.db.QueryContext(ctx, getMailRecipients, mailID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EveEntity
	for rows.Next() {
		var i EveEntity
		if err := rows.Scan(&i.ID, &i.Category, &i.Name); 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 getMailUnreadCount = `-- name: GetMailUnreadCount :one
SELECT COUNT(mails.id)
FROM mails
WHERE mails.my_character_id = ?
AND is_read IS FALSE
`

func (q *Queries) GetMailUnreadCount(ctx context.Context, myCharacterID int64) (int64, error) {
	row := q.db.QueryRowContext(ctx, getMailUnreadCount, myCharacterID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const listMailIDs = `-- name: ListMailIDs :many
SELECT mail_id
FROM mails
WHERE my_character_id = ?
`

func (q *Queries) ListMailIDs(ctx context.Context, myCharacterID int64) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, listMailIDs, myCharacterID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var mail_id int64
		if err := rows.Scan(&mail_id); err != nil {
			return nil, err
		}
		items = append(items, mail_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMailIDsForLabelOrdered = `-- name: ListMailIDsForLabelOrdered :many
SELECT mails.mail_id
FROM mails
JOIN mail_mail_labels ON mail_mail_labels.mail_id = mails.id
JOIN mail_labels ON mail_labels.id = mail_mail_labels.mail_label_id
WHERE mails.my_character_id = ?
AND label_id = ?
ORDER BY timestamp DESC
`

type ListMailIDsForLabelOrderedParams struct {
	MyCharacterID int64
	LabelID       int64
}

func (q *Queries) ListMailIDsForLabelOrdered(ctx context.Context, arg ListMailIDsForLabelOrderedParams) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, listMailIDsForLabelOrdered, arg.MyCharacterID, arg.LabelID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var mail_id int64
		if err := rows.Scan(&mail_id); err != nil {
			return nil, err
		}
		items = append(items, mail_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMailIDsForListOrdered = `-- name: ListMailIDsForListOrdered :many
SELECT mails.mail_id
FROM mails
JOIN mail_recipients ON mail_recipients.mail_id = mails.id
WHERE my_character_id = ?
AND mail_recipients.eve_entity_id = ?
ORDER BY timestamp DESC
`

type ListMailIDsForListOrderedParams struct {
	MyCharacterID int64
	EveEntityID   int64
}

func (q *Queries) ListMailIDsForListOrdered(ctx context.Context, arg ListMailIDsForListOrderedParams) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, listMailIDsForListOrdered, arg.MyCharacterID, arg.EveEntityID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var mail_id int64
		if err := rows.Scan(&mail_id); err != nil {
			return nil, err
		}
		items = append(items, mail_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMailIDsNoLabelOrdered = `-- name: ListMailIDsNoLabelOrdered :many
SELECT mails.mail_id
FROM mails
LEFT JOIN mail_mail_labels ON mail_mail_labels.mail_id = mails.id
WHERE my_character_id = ?
AND mail_mail_labels.mail_id IS NULL
ORDER BY timestamp DESC
`

func (q *Queries) ListMailIDsNoLabelOrdered(ctx context.Context, myCharacterID int64) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, listMailIDsNoLabelOrdered, myCharacterID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var mail_id int64
		if err := rows.Scan(&mail_id); err != nil {
			return nil, err
		}
		items = append(items, mail_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMailIDsOrdered = `-- name: ListMailIDsOrdered :many
SELECT mail_id
FROM mails
WHERE my_character_id = ?
ORDER BY timestamp DESC
`

func (q *Queries) ListMailIDsOrdered(ctx context.Context, myCharacterID int64) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, listMailIDsOrdered, myCharacterID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var mail_id int64
		if err := rows.Scan(&mail_id); err != nil {
			return nil, err
		}
		items = append(items, mail_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateMail = `-- name: UpdateMail :exec
UPDATE mails
SET is_read = ?2
WHERE id = ?1
`

type UpdateMailParams struct {
	ID     int64
	IsRead bool
}

func (q *Queries) UpdateMail(ctx context.Context, arg UpdateMailParams) error {
	_, err := q.db.ExecContext(ctx, updateMail, arg.ID, arg.IsRead)
	return err
}