inventory/database/sqlite/generated/query.sql.go

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

package sqlite

import (
	"context"
	"database/sql"
)

const addAnnotation = `-- name: AddAnnotation :exec
INSERT INTO annotations (user_id, object_id, event_id, check_in_id, events_object_id, text, datetime)
VALUES (?, ?, ?, ?, ?, ?, ?)
`

type AddAnnotationParams struct {
	UserID         int64
	ObjectID       sql.NullInt64
	EventID        sql.NullInt64
	CheckInID      sql.NullInt64
	EventsObjectID sql.NullInt64
	Text           string
	Datetime       string
}

func (q *Queries) AddAnnotation(ctx context.Context, arg AddAnnotationParams) error {
	_, err := q.db.ExecContext(ctx, addAnnotation,
		arg.UserID,
		arg.ObjectID,
		arg.EventID,
		arg.CheckInID,
		arg.EventsObjectID,
		arg.Text,
		arg.Datetime,
	)
	return err
}

const addCheckIn = `-- name: AddCheckIn :exec
INSERT INTO check_in (user_id, checkin_event_id, event_id, object_id, checkin_state_id, datetime)
VALUES (?, ?, ?, ?, ?, ?)
`

type AddCheckInParams struct {
	UserID         int64
	CheckinEventID int64
	EventID        sql.NullInt64
	ObjectID       sql.NullInt64
	CheckinStateID int64
	Datetime       string
}

func (q *Queries) AddCheckIn(ctx context.Context, arg AddCheckInParams) error {
	_, err := q.db.ExecContext(ctx, addCheckIn,
		arg.UserID,
		arg.CheckinEventID,
		arg.EventID,
		arg.ObjectID,
		arg.CheckinStateID,
		arg.Datetime,
	)
	return err
}

const addObject = `-- name: AddObject :exec
INSERT INTO objects (storagespace_id, name, description, serialnumber, created)
VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
`

type AddObjectParams struct {
	StoragespaceID int64
	Name           string
	Description    sql.NullString
	Serialnumber   sql.NullString
}

func (q *Queries) AddObject(ctx context.Context, arg AddObjectParams) error {
	_, err := q.db.ExecContext(ctx, addObject,
		arg.StoragespaceID,
		arg.Name,
		arg.Description,
		arg.Serialnumber,
	)
	return err
}

const addPicture = `-- name: AddPicture :exec
INSERT INTO pictures (user_id, storagespace_id, object_id, event_id, check_in_id, path, description, datetime)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
`

type AddPictureParams struct {
	UserID         int64
	StoragespaceID sql.NullInt64
	ObjectID       sql.NullInt64
	EventID        sql.NullInt64
	CheckInID      sql.NullInt64
	Path           string
	Description    sql.NullString
	Datetime       string
}

func (q *Queries) AddPicture(ctx context.Context, arg AddPictureParams) error {
	_, err := q.db.ExecContext(ctx, addPicture,
		arg.UserID,
		arg.StoragespaceID,
		arg.ObjectID,
		arg.EventID,
		arg.CheckInID,
		arg.Path,
		arg.Description,
		arg.Datetime,
	)
	return err
}

const addUser = `-- name: AddUser :exec
INSERT INTO users (username) VALUES (?)
`

func (q *Queries) AddUser(ctx context.Context, username string) error {
	_, err := q.db.ExecContext(ctx, addUser, username)
	return err
}

const addUserSession = `-- name: AddUserSession :exec
INSERT INTO user_sessions (user_id, session_token, created_at, valid_until, name)
VALUES (?, ?, ?, ?, ?)
`

type AddUserSessionParams struct {
	UserID       int64
	SessionToken string
	CreatedAt    string
	ValidUntil   string
	Name         sql.NullString
}

func (q *Queries) AddUserSession(ctx context.Context, arg AddUserSessionParams) error {
	_, err := q.db.ExecContext(ctx, addUserSession,
		arg.UserID,
		arg.SessionToken,
		arg.CreatedAt,
		arg.ValidUntil,
		arg.Name,
	)
	return err
}

const createEvent = `-- name: CreateEvent :exec
INSERT INTO events (user_id, name, description, location, start_date, end_date)
VALUES (?, ?, ?, ?, ?, ?)
`

type CreateEventParams struct {
	UserID      int64
	Name        string
	Description sql.NullString
	Location    sql.NullString
	StartDate   string
	EndDate     string
}

func (q *Queries) CreateEvent(ctx context.Context, arg CreateEventParams) error {
	_, err := q.db.ExecContext(ctx, createEvent,
		arg.UserID,
		arg.Name,
		arg.Description,
		arg.Location,
		arg.StartDate,
		arg.EndDate,
	)
	return err
}

const createStorageSpace = `-- name: CreateStorageSpace :exec
INSERT INTO storagespace (parent, location, name) VALUES (?, ?, ?)
`

type CreateStorageSpaceParams struct {
	Parent   sql.NullInt64
	Location sql.NullString
	Name     string
}

func (q *Queries) CreateStorageSpace(ctx context.Context, arg CreateStorageSpaceParams) error {
	_, err := q.db.ExecContext(ctx, createStorageSpace, arg.Parent, arg.Location, arg.Name)
	return err
}

const getAllStorageSpaces = `-- name: GetAllStorageSpaces :many
SELECT id, parent, location, name FROM storagespace
`

func (q *Queries) GetAllStorageSpaces(ctx context.Context) ([]Storagespace, error) {
	rows, err := q.db.QueryContext(ctx, getAllStorageSpaces)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Storagespace
	for rows.Next() {
		var i Storagespace
		if err := rows.Scan(
			&i.ID,
			&i.Parent,
			&i.Location,
			&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 getAllUsers = `-- name: GetAllUsers :many
SELECT id, username FROM users
`

func (q *Queries) GetAllUsers(ctx context.Context) ([]User, error) {
	rows, err := q.db.QueryContext(ctx, getAllUsers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(&i.ID, &i.Username); 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 getChildStorageSpaces = `-- name: GetChildStorageSpaces :many
SELECT id, parent, location, name FROM storagespace WHERE parent = ?
`

func (q *Queries) GetChildStorageSpaces(ctx context.Context, parent sql.NullInt64) ([]Storagespace, error) {
	rows, err := q.db.QueryContext(ctx, getChildStorageSpaces, parent)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Storagespace
	for rows.Next() {
		var i Storagespace
		if err := rows.Scan(
			&i.ID,
			&i.Parent,
			&i.Location,
			&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 getEventCheckIns = `-- name: GetEventCheckIns :many
SELECT check_in_id, username, event_name, object_name, datetime, checkin_state FROM check_in_log WHERE event_name = ?
`

func (q *Queries) GetEventCheckIns(ctx context.Context, eventName string) ([]CheckInLog, error) {
	rows, err := q.db.QueryContext(ctx, getEventCheckIns, eventName)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckInLog
	for rows.Next() {
		var i CheckInLog
		if err := rows.Scan(
			&i.CheckInID,
			&i.Username,
			&i.EventName,
			&i.ObjectName,
			&i.Datetime,
			&i.CheckinState,
		); 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 getEventObjects = `-- name: GetEventObjects :many
SELECT objects.id, objects.storagespace_id, objects.name, objects.description, objects.serialnumber, objects.created 
FROM objects
JOIN events_objects ON objects.id = events_objects.object_id
WHERE events_objects.event_id = ?
`

func (q *Queries) GetEventObjects(ctx context.Context, eventID int64) ([]Object, error) {
	rows, err := q.db.QueryContext(ctx, getEventObjects, eventID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Object
	for rows.Next() {
		var i Object
		if err := rows.Scan(
			&i.ID,
			&i.StoragespaceID,
			&i.Name,
			&i.Description,
			&i.Serialnumber,
			&i.Created,
		); 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 getEventPictures = `-- name: GetEventPictures :many
SELECT id, user_id, storagespace_id, object_id, event_id, check_in_id, path, description, datetime FROM pictures WHERE event_id = ?
`

func (q *Queries) GetEventPictures(ctx context.Context, eventID sql.NullInt64) ([]Picture, error) {
	rows, err := q.db.QueryContext(ctx, getEventPictures, eventID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Picture
	for rows.Next() {
		var i Picture
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.StoragespaceID,
			&i.ObjectID,
			&i.EventID,
			&i.CheckInID,
			&i.Path,
			&i.Description,
			&i.Datetime,
		); 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 getObjectAnnotations = `-- name: GetObjectAnnotations :many
SELECT id, user_id, object_id, event_id, check_in_id, events_object_id, text, datetime FROM annotations WHERE object_id = ?
`

func (q *Queries) GetObjectAnnotations(ctx context.Context, objectID sql.NullInt64) ([]Annotation, error) {
	rows, err := q.db.QueryContext(ctx, getObjectAnnotations, objectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Annotation
	for rows.Next() {
		var i Annotation
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.ObjectID,
			&i.EventID,
			&i.CheckInID,
			&i.EventsObjectID,
			&i.Text,
			&i.Datetime,
		); 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 getObjectsByStorageID = `-- name: GetObjectsByStorageID :many
SELECT id, storagespace_id, name, description, serialnumber, created 
FROM objects WHERE storagespace_id = ?
`

func (q *Queries) GetObjectsByStorageID(ctx context.Context, storagespaceID int64) ([]Object, error) {
	rows, err := q.db.QueryContext(ctx, getObjectsByStorageID, storagespaceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Object
	for rows.Next() {
		var i Object
		if err := rows.Scan(
			&i.ID,
			&i.StoragespaceID,
			&i.Name,
			&i.Description,
			&i.Serialnumber,
			&i.Created,
		); 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 getObjectsInStorage = `-- name: GetObjectsInStorage :many
SELECT object_id, object_name, storage_location FROM object_storage WHERE storage_location = ?
`

func (q *Queries) GetObjectsInStorage(ctx context.Context, storageLocation sql.NullString) ([]ObjectStorage, error) {
	rows, err := q.db.QueryContext(ctx, getObjectsInStorage, storageLocation)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ObjectStorage
	for rows.Next() {
		var i ObjectStorage
		if err := rows.Scan(&i.ObjectID, &i.ObjectName, &i.StorageLocation); 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 getStorageSpaceByID = `-- name: GetStorageSpaceByID :one
SELECT id, parent, location, name FROM storagespace WHERE id = ?
`

func (q *Queries) GetStorageSpaceByID(ctx context.Context, id int64) (Storagespace, error) {
	row := q.db.QueryRowContext(ctx, getStorageSpaceByID, id)
	var i Storagespace
	err := row.Scan(
		&i.ID,
		&i.Parent,
		&i.Location,
		&i.Name,
	)
	return i, err
}

const getUserByID = `-- name: GetUserByID :one
SELECT id, username FROM users WHERE id = ?
`

func (q *Queries) GetUserByID(ctx context.Context, id int64) (User, error) {
	row := q.db.QueryRowContext(ctx, getUserByID, id)
	var i User
	err := row.Scan(&i.ID, &i.Username)
	return i, err
}

const getUserEvents = `-- name: GetUserEvents :many
SELECT event_id, event_name, description, location, start_date, end_date, organizer FROM event_details WHERE organizer = ?
`

func (q *Queries) GetUserEvents(ctx context.Context, organizer string) ([]EventDetail, error) {
	rows, err := q.db.QueryContext(ctx, getUserEvents, organizer)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []EventDetail
	for rows.Next() {
		var i EventDetail
		if err := rows.Scan(
			&i.EventID,
			&i.EventName,
			&i.Description,
			&i.Location,
			&i.StartDate,
			&i.EndDate,
			&i.Organizer,
		); 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 getUserSessions = `-- name: GetUserSessions :many
SELECT user_id, username, session_token, created_at, valid_until FROM user_sessions_view WHERE user_id = ?
`

func (q *Queries) GetUserSessions(ctx context.Context, userID int64) ([]UserSessionsView, error) {
	rows, err := q.db.QueryContext(ctx, getUserSessions, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []UserSessionsView
	for rows.Next() {
		var i UserSessionsView
		if err := rows.Scan(
			&i.UserID,
			&i.Username,
			&i.SessionToken,
			&i.CreatedAt,
			&i.ValidUntil,
		); 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
}