profile_status.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: profile_status.sql

package db

import (
	"context"
	"database/sql"
	"encoding/json"
	"time"

	"github.com/google/uuid"
	"github.com/lib/pq"
	"github.com/sqlc-dev/pqtype"
)

const getProfileStatusByIdAndProject = `-- name: GetProfileStatusByIdAndProject :one
SELECT p.id, p.name, ps.profile_status, ps.last_updated FROM profile_status ps
INNER JOIN profiles p ON p.id = ps.profile_id
WHERE p.id = $1 AND p.project_id = $2
`

type GetProfileStatusByIdAndProjectParams struct {
	ID        uuid.UUID `json:"id"`
	ProjectID uuid.UUID `json:"project_id"`
}

type GetProfileStatusByIdAndProjectRow struct {
	ID            uuid.UUID       `json:"id"`
	Name          string          `json:"name"`
	ProfileStatus EvalStatusTypes `json:"profile_status"`
	LastUpdated   time.Time       `json:"last_updated"`
}

func (q *Queries) GetProfileStatusByIdAndProject(ctx context.Context, arg GetProfileStatusByIdAndProjectParams) (GetProfileStatusByIdAndProjectRow, error) {
	row := q.db.QueryRowContext(ctx, getProfileStatusByIdAndProject, arg.ID, arg.ProjectID)
	var i GetProfileStatusByIdAndProjectRow
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.ProfileStatus,
		&i.LastUpdated,
	)
	return i, err
}

const getProfileStatusByNameAndProject = `-- name: GetProfileStatusByNameAndProject :one
SELECT p.id, p.name, ps.profile_status, ps.last_updated FROM profile_status ps
INNER JOIN profiles p ON p.id = ps.profile_id
WHERE lower(p.name) = lower($2) AND p.project_id = $1
`

type GetProfileStatusByNameAndProjectParams struct {
	ProjectID uuid.UUID `json:"project_id"`
	Name      string    `json:"name"`
}

type GetProfileStatusByNameAndProjectRow struct {
	ID            uuid.UUID       `json:"id"`
	Name          string          `json:"name"`
	ProfileStatus EvalStatusTypes `json:"profile_status"`
	LastUpdated   time.Time       `json:"last_updated"`
}

func (q *Queries) GetProfileStatusByNameAndProject(ctx context.Context, arg GetProfileStatusByNameAndProjectParams) (GetProfileStatusByNameAndProjectRow, error) {
	row := q.db.QueryRowContext(ctx, getProfileStatusByNameAndProject, arg.ProjectID, arg.Name)
	var i GetProfileStatusByNameAndProjectRow
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.ProfileStatus,
		&i.LastUpdated,
	)
	return i, err
}

const getProfileStatusByProject = `-- name: GetProfileStatusByProject :many
SELECT p.id, p.name, ps.profile_status, ps.last_updated FROM profile_status ps
INNER JOIN profiles p ON p.id = ps.profile_id
WHERE p.project_id = $1
`

type GetProfileStatusByProjectRow struct {
	ID            uuid.UUID       `json:"id"`
	Name          string          `json:"name"`
	ProfileStatus EvalStatusTypes `json:"profile_status"`
	LastUpdated   time.Time       `json:"last_updated"`
}

func (q *Queries) GetProfileStatusByProject(ctx context.Context, projectID uuid.UUID) ([]GetProfileStatusByProjectRow, error) {
	rows, err := q.db.QueryContext(ctx, getProfileStatusByProject, projectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetProfileStatusByProjectRow{}
	for rows.Next() {
		var i GetProfileStatusByProjectRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.ProfileStatus,
			&i.LastUpdated,
		); 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 listOldestRuleEvaluationsByEntityID = `-- name: ListOldestRuleEvaluationsByEntityID :many

SELECT ere.entity_instance_id, MIN(es.evaluation_time)::timestamp AS oldest_last_updated
FROM evaluation_rule_entities AS ere
    INNER JOIN latest_evaluation_statuses AS les ON ere.id = les.rule_entity_id
    INNER JOIN evaluation_statuses AS es ON les.evaluation_history_id = es.id
WHERE ere.entity_instance_id = ANY ($1::uuid[])
GROUP BY ere.entity_instance_id
`

type ListOldestRuleEvaluationsByEntityIDRow struct {
	EntityInstanceID  uuid.UUID `json:"entity_instance_id"`
	OldestLastUpdated time.Time `json:"oldest_last_updated"`
}

// ListOldestRuleEvaluationsByEntityID returns the oldest evaluation time for each entity.
// cast after MIN is required due to a known bug in sqlc: https://github.com/sqlc-dev/sqlc/issues/1965
func (q *Queries) ListOldestRuleEvaluationsByEntityID(ctx context.Context, entityIds []uuid.UUID) ([]ListOldestRuleEvaluationsByEntityIDRow, error) {
	rows, err := q.db.QueryContext(ctx, listOldestRuleEvaluationsByEntityID, pq.Array(entityIds))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListOldestRuleEvaluationsByEntityIDRow{}
	for rows.Next() {
		var i ListOldestRuleEvaluationsByEntityIDRow
		if err := rows.Scan(&i.EntityInstanceID, &i.OldestLastUpdated); 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 listOldestRuleEvaluationsByRepositoryId = `-- name: ListOldestRuleEvaluationsByRepositoryId :many

SELECT ere.entity_instance_id::uuid AS repository_id, MIN(es.evaluation_time)::timestamp AS oldest_last_updated
FROM evaluation_rule_entities AS ere
    INNER JOIN latest_evaluation_statuses AS les ON ere.id = les.rule_entity_id
    INNER JOIN evaluation_statuses AS es ON les.evaluation_history_id = es.id
WHERE ere.entity_instance_id = ANY ($1::uuid[])
AND ere.entity_type = 'repository'
GROUP BY ere.entity_instance_id
`

type ListOldestRuleEvaluationsByRepositoryIdRow struct {
	RepositoryID      uuid.UUID `json:"repository_id"`
	OldestLastUpdated time.Time `json:"oldest_last_updated"`
}

// ListOldestRuleEvaluationsByRepositoryId has casts in select statement as sqlc generates incorrect types.
// cast after MIN is required due to a known bug in sqlc: https://github.com/sqlc-dev/sqlc/issues/1965
// DEPRECATED: Use ListOldestRuleEvaluationsByEntityID instead
func (q *Queries) ListOldestRuleEvaluationsByRepositoryId(ctx context.Context, repositoryIds []uuid.UUID) ([]ListOldestRuleEvaluationsByRepositoryIdRow, error) {
	rows, err := q.db.QueryContext(ctx, listOldestRuleEvaluationsByRepositoryId, pq.Array(repositoryIds))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListOldestRuleEvaluationsByRepositoryIdRow{}
	for rows.Next() {
		var i ListOldestRuleEvaluationsByRepositoryIdRow
		if err := rows.Scan(&i.RepositoryID, &i.OldestLastUpdated); 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 listRuleEvaluationsByProfileId = `-- name: ListRuleEvaluationsByProfileId :many
WITH
   eval_details AS (
   SELECT
       id,
       status AS eval_status,
       details AS eval_details,
       evaluation_time AS eval_last_updated
   FROM evaluation_statuses
   ),
   remediation_details AS (
       SELECT
           evaluation_id,
           status AS rem_status,
           details AS rem_details,
           metadata AS rem_metadata,
           created_at AS rem_last_updated
       FROM remediation_events
   ),
   alert_details AS (
       SELECT
           evaluation_id,
           status AS alert_status,
           details AS alert_details,
           metadata AS alert_metadata,
           created_at AS alert_last_updated
       FROM alert_events
   )

SELECT
    ed.eval_status,
    ed.eval_last_updated,
    ed.eval_details,
    rd.rem_status,
    rd.rem_details,
    rd.rem_metadata,
    rd.rem_last_updated,
    ad.alert_status,
    ad.alert_details,
    ad.alert_metadata,
    ad.alert_last_updated,
    ed.id AS rule_evaluation_id,
    ere.entity_type,
    ri.name AS rule_name,
    prov.name AS provider,
    rt.name AS rule_type_name,
    rt.severity_value as rule_type_severity_value,
    rt.id AS rule_type_id,
    rt.guidance as rule_type_guidance,
    rt.display_name as rule_type_display_name,
    ere.entity_instance_id as entity_id,
    ei.name as entity_name,
    ei.project_id as project_id,
    rt.release_phase as rule_type_release_phase,
    eo.output AS eval_output
FROM latest_evaluation_statuses les
         INNER JOIN evaluation_rule_entities ere ON ere.id = les.rule_entity_id
         INNER JOIN eval_details ed ON ed.id = les.evaluation_history_id
         INNER JOIN remediation_details rd ON rd.evaluation_id = les.evaluation_history_id
         INNER JOIN alert_details ad ON ad.evaluation_id = les.evaluation_history_id
         INNER JOIN rule_instances AS ri ON ri.id = ere.rule_id
         INNER JOIN rule_type rt ON rt.id = ri.rule_type_id
         INNER JOIN entity_instances ei ON ei.id = ere.entity_instance_id
         INNER JOIN providers prov ON prov.id = ei.provider_id
         LEFT JOIN evaluation_outputs eo ON eo.id = les.evaluation_history_id AND $2::boolean
WHERE les.profile_id = $1
    AND (ere.entity_instance_id = $3::UUID OR $3::UUID IS NULL)
    AND (ei.name = $4 OR $4 IS NULL)
    AND (rt.name = $5 OR $5 IS NULL)
    AND (lower(ri.name) = lower($6) OR $6 IS NULL)
`

type ListRuleEvaluationsByProfileIdParams struct {
	ProfileID      uuid.UUID      `json:"profile_id"`
	IncludeOutputs bool           `json:"include_outputs"`
	EntityID       uuid.NullUUID  `json:"entity_id"`
	EntityName     sql.NullString `json:"entity_name"`
	RuleTypeName   sql.NullString `json:"rule_type_name"`
	RuleName       sql.NullString `json:"rule_name"`
}

type ListRuleEvaluationsByProfileIdRow struct {
	EvalStatus            EvalStatusTypes        `json:"eval_status"`
	EvalLastUpdated       time.Time              `json:"eval_last_updated"`
	EvalDetails           string                 `json:"eval_details"`
	RemStatus             RemediationStatusTypes `json:"rem_status"`
	RemDetails            string                 `json:"rem_details"`
	RemMetadata           json.RawMessage        `json:"rem_metadata"`
	RemLastUpdated        time.Time              `json:"rem_last_updated"`
	AlertStatus           AlertStatusTypes       `json:"alert_status"`
	AlertDetails          string                 `json:"alert_details"`
	AlertMetadata         json.RawMessage        `json:"alert_metadata"`
	AlertLastUpdated      time.Time              `json:"alert_last_updated"`
	RuleEvaluationID      uuid.UUID              `json:"rule_evaluation_id"`
	EntityType            Entities               `json:"entity_type"`
	RuleName              string                 `json:"rule_name"`
	Provider              string                 `json:"provider"`
	RuleTypeName          string                 `json:"rule_type_name"`
	RuleTypeSeverityValue Severity               `json:"rule_type_severity_value"`
	RuleTypeID            uuid.UUID              `json:"rule_type_id"`
	RuleTypeGuidance      string                 `json:"rule_type_guidance"`
	RuleTypeDisplayName   string                 `json:"rule_type_display_name"`
	EntityID              uuid.UUID              `json:"entity_id"`
	EntityName            string                 `json:"entity_name"`
	ProjectID             uuid.UUID              `json:"project_id"`
	RuleTypeReleasePhase  ReleaseStatus          `json:"rule_type_release_phase"`
	EvalOutput            pqtype.NullRawMessage  `json:"eval_output"`
}

func (q *Queries) ListRuleEvaluationsByProfileId(ctx context.Context, arg ListRuleEvaluationsByProfileIdParams) ([]ListRuleEvaluationsByProfileIdRow, error) {
	rows, err := q.db.QueryContext(ctx, listRuleEvaluationsByProfileId,
		arg.ProfileID,
		arg.IncludeOutputs,
		arg.EntityID,
		arg.EntityName,
		arg.RuleTypeName,
		arg.RuleName,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListRuleEvaluationsByProfileIdRow{}
	for rows.Next() {
		var i ListRuleEvaluationsByProfileIdRow
		if err := rows.Scan(
			&i.EvalStatus,
			&i.EvalLastUpdated,
			&i.EvalDetails,
			&i.RemStatus,
			&i.RemDetails,
			&i.RemMetadata,
			&i.RemLastUpdated,
			&i.AlertStatus,
			&i.AlertDetails,
			&i.AlertMetadata,
			&i.AlertLastUpdated,
			&i.RuleEvaluationID,
			&i.EntityType,
			&i.RuleName,
			&i.Provider,
			&i.RuleTypeName,
			&i.RuleTypeSeverityValue,
			&i.RuleTypeID,
			&i.RuleTypeGuidance,
			&i.RuleTypeDisplayName,
			&i.EntityID,
			&i.EntityName,
			&i.ProjectID,
			&i.RuleTypeReleasePhase,
			&i.EvalOutput,
		); 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
}