// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: query.sql

package queries

import (
	"context"
	"database/sql"
)

const createIncident = `-- name: CreateIncident :one
INSERT INTO incidents (
    "description", "short_description", "urgency", "impact", "state", "external_id", "assignment_group", "assigned_to", "category", "sub_category", "created_at", "sys_id"
) VALUES(
    ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
)
RETURNING id, external_id, created_at, incident_number, description, short_description, urgency, impact, state, assignment_group, assigned_to, category, sub_category, sys_id, updated_at
`

type CreateIncidentParams struct {
	Description      sql.NullString
	ShortDescription sql.NullString
	Urgency          sql.NullInt64
	Impact           sql.NullInt64
	State            sql.NullInt64
	ExternalID       string
	AssignmentGroup  sql.NullString
	AssignedTo       sql.NullString
	Category         sql.NullString
	SubCategory      sql.NullString
	CreatedAt        sql.NullTime
	SysID            sql.NullString
}

func (q *Queries) CreateIncident(ctx context.Context, arg CreateIncidentParams) (Incident, error) {
	row := q.db.QueryRowContext(ctx, createIncident,
		arg.Description,
		arg.ShortDescription,
		arg.Urgency,
		arg.Impact,
		arg.State,
		arg.ExternalID,
		arg.AssignmentGroup,
		arg.AssignedTo,
		arg.Category,
		arg.SubCategory,
		arg.CreatedAt,
		arg.SysID,
	)
	var i Incident
	err := row.Scan(
		&i.ID,
		&i.ExternalID,
		&i.CreatedAt,
		&i.IncidentNumber,
		&i.Description,
		&i.ShortDescription,
		&i.Urgency,
		&i.Impact,
		&i.State,
		&i.AssignmentGroup,
		&i.AssignedTo,
		&i.Category,
		&i.SubCategory,
		&i.SysID,
		&i.UpdatedAt,
	)
	return i, err
}

const createIncoming = `-- name: CreateIncoming :one
INSERT INTO "Incoming" (
    "incident_number", "description", "short_description", "urgency", "impact", "state", "external_id", "work_notes", "assignment_group", "assigned_to", "category", "sub_category", "created_at"
) VALUES(
    ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
)
RETURNING id, incident_number, description, short_description, urgency, impact, state, external_id, work_notes, assignment_group, assigned_to, category, sub_category, created_at
`

type CreateIncomingParams struct {
	IncidentNumber   sql.NullString
	Description      sql.NullString
	ShortDescription sql.NullString
	Urgency          sql.NullString
	Impact           sql.NullString
	State            sql.NullString
	ExternalID       sql.NullString
	WorkNotes        sql.NullString
	AssignmentGroup  sql.NullString
	AssignedTo       sql.NullString
	Category         sql.NullString
	SubCategory      sql.NullString
	CreatedAt        sql.NullTime
}

func (q *Queries) CreateIncoming(ctx context.Context, arg CreateIncomingParams) (Incoming, error) {
	row := q.db.QueryRowContext(ctx, createIncoming,
		arg.IncidentNumber,
		arg.Description,
		arg.ShortDescription,
		arg.Urgency,
		arg.Impact,
		arg.State,
		arg.ExternalID,
		arg.WorkNotes,
		arg.AssignmentGroup,
		arg.AssignedTo,
		arg.Category,
		arg.SubCategory,
		arg.CreatedAt,
	)
	var i Incoming
	err := row.Scan(
		&i.ID,
		&i.IncidentNumber,
		&i.Description,
		&i.ShortDescription,
		&i.Urgency,
		&i.Impact,
		&i.State,
		&i.ExternalID,
		&i.WorkNotes,
		&i.AssignmentGroup,
		&i.AssignedTo,
		&i.Category,
		&i.SubCategory,
		&i.CreatedAt,
	)
	return i, err
}

const createWorkNote = `-- name: CreateWorkNote :one
INSERT into worknotes (
        "incident_number", "note", "created_at"
) VALUES(
    ?, ?, CURRENT_TIMESTAMP
)
RETURNING id, incident_number, note, created_at
`

type CreateWorkNoteParams struct {
	IncidentNumber string
	Note           sql.NullString
}

func (q *Queries) CreateWorkNote(ctx context.Context, arg CreateWorkNoteParams) (Worknote, error) {
	row := q.db.QueryRowContext(ctx, createWorkNote, arg.IncidentNumber, arg.Note)
	var i Worknote
	err := row.Scan(
		&i.ID,
		&i.IncidentNumber,
		&i.Note,
		&i.CreatedAt,
	)
	return i, err
}

const getIncident = `-- name: GetIncident :one
SELECT id, external_id, created_at, incident_number, description, short_description, urgency, impact, state, assignment_group, assigned_to, category, sub_category, sys_id, updated_at from incidents
WHERE incident_number = ?1
`

func (q *Queries) GetIncident(ctx context.Context, incidentnumber sql.NullString) (Incident, error) {
	row := q.db.QueryRowContext(ctx, getIncident, incidentnumber)
	var i Incident
	err := row.Scan(
		&i.ID,
		&i.ExternalID,
		&i.CreatedAt,
		&i.IncidentNumber,
		&i.Description,
		&i.ShortDescription,
		&i.Urgency,
		&i.Impact,
		&i.State,
		&i.AssignmentGroup,
		&i.AssignedTo,
		&i.Category,
		&i.SubCategory,
		&i.SysID,
		&i.UpdatedAt,
	)
	return i, err
}

const getIncidentReport = `-- name: GetIncidentReport :many
SELECT incidents.id, incidents.external_id, incidents.created_at, incidents.incident_number, incidents.description, incidents.short_description, incidents.urgency, incidents.impact, incidents.state, incidents.assignment_group, incidents.assigned_to, incidents.category, incidents.sub_category, incidents.sys_id, incidents.updated_at, IFNULL(GROUP_CONCAT(worknotes.note, '<br />'), ' ') AS all_notes
FROM incidents LEFT JOIN worknotes ON incidents.incident_number = worknotes.incident_number
GROUP BY incidents.id
`

type GetIncidentReportRow struct {
	ID               int64
	ExternalID       string
	CreatedAt        sql.NullTime
	IncidentNumber   sql.NullString
	Description      sql.NullString
	ShortDescription sql.NullString
	Urgency          sql.NullInt64
	Impact           sql.NullInt64
	State            sql.NullInt64
	AssignmentGroup  sql.NullString
	AssignedTo       sql.NullString
	Category         sql.NullString
	SubCategory      sql.NullString
	SysID            sql.NullString
	UpdatedAt        sql.NullTime
	AllNotes         interface{}
}

func (q *Queries) GetIncidentReport(ctx context.Context) ([]GetIncidentReportRow, error) {
	rows, err := q.db.QueryContext(ctx, getIncidentReport)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetIncidentReportRow
	for rows.Next() {
		var i GetIncidentReportRow
		if err := rows.Scan(
			&i.ID,
			&i.ExternalID,
			&i.CreatedAt,
			&i.IncidentNumber,
			&i.Description,
			&i.ShortDescription,
			&i.Urgency,
			&i.Impact,
			&i.State,
			&i.AssignmentGroup,
			&i.AssignedTo,
			&i.Category,
			&i.SubCategory,
			&i.SysID,
			&i.UpdatedAt,
			&i.AllNotes,
		); 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 getIncidentWorkNotes = `-- name: GetIncidentWorkNotes :many
SELECT id, incident_number, note, created_at from worknotes
WHERE incident_number = ?1
`

func (q *Queries) GetIncidentWorkNotes(ctx context.Context, incidentnumber string) ([]Worknote, error) {
	rows, err := q.db.QueryContext(ctx, getIncidentWorkNotes, incidentnumber)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Worknote
	for rows.Next() {
		var i Worknote
		if err := rows.Scan(
			&i.ID,
			&i.IncidentNumber,
			&i.Note,
			&i.CreatedAt,
		); 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 listIncidents = `-- name: ListIncidents :many
SELECT id, external_id, created_at, incident_number, description, short_description, urgency, impact, state, assignment_group, assigned_to, category, sub_category, sys_id, updated_at FROM incidents
`

func (q *Queries) ListIncidents(ctx context.Context) ([]Incident, error) {
	rows, err := q.db.QueryContext(ctx, listIncidents)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Incident
	for rows.Next() {
		var i Incident
		if err := rows.Scan(
			&i.ID,
			&i.ExternalID,
			&i.CreatedAt,
			&i.IncidentNumber,
			&i.Description,
			&i.ShortDescription,
			&i.Urgency,
			&i.Impact,
			&i.State,
			&i.AssignmentGroup,
			&i.AssignedTo,
			&i.Category,
			&i.SubCategory,
			&i.SysID,
			&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 listIncoming = `-- name: ListIncoming :many
SELECT id, incident_number, description, short_description, urgency, impact, state, external_id, work_notes, assignment_group, assigned_to, category, sub_category, created_at FROM "Incoming"
ORDER BY "id"
`

func (q *Queries) ListIncoming(ctx context.Context) ([]Incoming, error) {
	rows, err := q.db.QueryContext(ctx, listIncoming)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Incoming
	for rows.Next() {
		var i Incoming
		if err := rows.Scan(
			&i.ID,
			&i.IncidentNumber,
			&i.Description,
			&i.ShortDescription,
			&i.Urgency,
			&i.Impact,
			&i.State,
			&i.ExternalID,
			&i.WorkNotes,
			&i.AssignmentGroup,
			&i.AssignedTo,
			&i.Category,
			&i.SubCategory,
			&i.CreatedAt,
		); 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 listWorkNotes = `-- name: ListWorkNotes :many
SELECT id, incident_number, note, created_at from worknotes
`

func (q *Queries) ListWorkNotes(ctx context.Context) ([]Worknote, error) {
	rows, err := q.db.QueryContext(ctx, listWorkNotes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Worknote
	for rows.Next() {
		var i Worknote
		if err := rows.Scan(
			&i.ID,
			&i.IncidentNumber,
			&i.Note,
			&i.CreatedAt,
		); 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 updateIncident = `-- name: UpdateIncident :exec
UPDATE incidents
SET
    external_id = ?,
    description = ?,
    short_description = ?,
    urgency = ?,
    impact = ?,
    state = ?,
    assignment_group = ?,
    assigned_to = ?,
    category = ?,
    sub_category = ?,
    updated_at = CURRENT_TIMESTAMP
WHERE incident_number = ?
`

type UpdateIncidentParams struct {
	ExternalID       string
	Description      sql.NullString
	ShortDescription sql.NullString
	Urgency          sql.NullInt64
	Impact           sql.NullInt64
	State            sql.NullInt64
	AssignmentGroup  sql.NullString
	AssignedTo       sql.NullString
	Category         sql.NullString
	SubCategory      sql.NullString
	IncidentNumber   sql.NullString
}

func (q *Queries) UpdateIncident(ctx context.Context, arg UpdateIncidentParams) error {
	_, err := q.db.ExecContext(ctx, updateIncident,
		arg.ExternalID,
		arg.Description,
		arg.ShortDescription,
		arg.Urgency,
		arg.Impact,
		arg.State,
		arg.AssignmentGroup,
		arg.AssignedTo,
		arg.Category,
		arg.SubCategory,
		arg.IncidentNumber,
	)
	return err
}

const updateIncidentNumber = `-- name: UpdateIncidentNumber :exec
UPDATE incidents
SET incident_number = ?1
WHERE external_id = ?2
`

type UpdateIncidentNumberParams struct {
	IncidentNumber sql.NullString
	ExternalId     string
}

func (q *Queries) UpdateIncidentNumber(ctx context.Context, arg UpdateIncidentNumberParams) error {
	_, err := q.db.ExecContext(ctx, updateIncidentNumber, arg.IncidentNumber, arg.ExternalId)
	return err
}

const updateIncidentNumberSysId = `-- name: UpdateIncidentNumberSysId :exec
UPDATE incidents
SET incident_number = ?1
WHERE sys_id = ?2
`

type UpdateIncidentNumberSysIdParams struct {
	IncidentNumber sql.NullString
	SysId          sql.NullString
}

func (q *Queries) UpdateIncidentNumberSysId(ctx context.Context, arg UpdateIncidentNumberSysIdParams) error {
	_, err := q.db.ExecContext(ctx, updateIncidentNumberSysId, arg.IncidentNumber, arg.SysId)
	return err
}

const updateIncidentState = `-- name: UpdateIncidentState :exec
UPDATE incidents
SET state = ?1, updated_at = CURRENT_TIMESTAMP
WHERE incident_number = ?2
`

type UpdateIncidentStateParams struct {
	State          sql.NullInt64
	IncidentNumber sql.NullString
}

func (q *Queries) UpdateIncidentState(ctx context.Context, arg UpdateIncidentStateParams) error {
	_, err := q.db.ExecContext(ctx, updateIncidentState, arg.State, arg.IncidentNumber)
	return err
}