3930 lines
117 KiB
Go
3930 lines
117 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
||
// versions:
|
||
// sqlc v1.28.0
|
||
// source: queries.sql
|
||
|
||
package sqlcgen
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"encoding/json"
|
||
"time"
|
||
|
||
"github.com/google/uuid"
|
||
"github.com/lib/pq"
|
||
)
|
||
|
||
const accountPagination = `-- name: AccountPagination :many
|
||
SELECT a.id, a.user_id, a.created_at, a.deleted
|
||
FROM account a ORDER BY a.created_at DESC LIMIT $1 OFFSET $2
|
||
`
|
||
|
||
type AccountPaginationParams struct {
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
Offset int32 `db:"offset" json:"offset"`
|
||
}
|
||
|
||
type AccountPaginationRow struct {
|
||
ID uuid.UUID `db:"id" json:"id"`
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
Deleted sql.NullBool `db:"deleted" json:"deleted"`
|
||
}
|
||
|
||
func (q *Queries) AccountPagination(ctx context.Context, arg AccountPaginationParams) ([]AccountPaginationRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, accountPagination, arg.Limit, arg.Offset)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []AccountPaginationRow
|
||
for rows.Next() {
|
||
var i AccountPaginationRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.UserID,
|
||
&i.CreatedAt,
|
||
&i.Deleted,
|
||
); 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 addAmoAccountUser = `-- name: AddAmoAccountUser :exec
|
||
INSERT INTO usersAmo (AmoID, AmoUserID, Name, Email, Role, "Group")
|
||
VALUES ($1, $2, $3, $4, $5, $6)
|
||
`
|
||
|
||
type AddAmoAccountUserParams struct {
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Amouserid int32 `db:"amouserid" json:"amouserid"`
|
||
Name string `db:"name" json:"name"`
|
||
Email string `db:"email" json:"email"`
|
||
Role int32 `db:"role" json:"role"`
|
||
Group int32 `db:"Group" json:"Group"`
|
||
}
|
||
|
||
func (q *Queries) AddAmoAccountUser(ctx context.Context, arg AddAmoAccountUserParams) error {
|
||
_, err := q.db.ExecContext(ctx, addAmoAccountUser,
|
||
arg.Amoid,
|
||
arg.Amouserid,
|
||
arg.Name,
|
||
arg.Email,
|
||
arg.Role,
|
||
arg.Group,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const allServiceStatistics = `-- name: AllServiceStatistics :one
|
||
WITH Registrations AS (
|
||
SELECT COUNT(*) AS registration_count
|
||
FROM account
|
||
WHERE created_at >= to_timestamp($1) AND created_at <= to_timestamp($2)
|
||
),
|
||
Quizes AS (
|
||
SELECT COUNT(*) AS quiz_count
|
||
FROM quiz
|
||
WHERE deleted = false AND created_at >= to_timestamp($1) AND created_at <= to_timestamp($2)
|
||
),
|
||
Results AS (
|
||
SELECT COUNT(*) AS result_count
|
||
FROM answer
|
||
WHERE result = true AND created_at >= to_timestamp($1) AND created_at <= to_timestamp($2)
|
||
)
|
||
SELECT
|
||
(SELECT registration_count FROM Registrations) AS registrations,
|
||
(SELECT quiz_count FROM Quizes) AS quizes,
|
||
(SELECT result_count FROM Results) AS results
|
||
`
|
||
|
||
type AllServiceStatisticsParams struct {
|
||
ToTimestamp float64 `db:"to_timestamp" json:"to_timestamp"`
|
||
ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
|
||
}
|
||
|
||
type AllServiceStatisticsRow struct {
|
||
Registrations int64 `db:"registrations" json:"registrations"`
|
||
Quizes int64 `db:"quizes" json:"quizes"`
|
||
Results int64 `db:"results" json:"results"`
|
||
}
|
||
|
||
func (q *Queries) AllServiceStatistics(ctx context.Context, arg AllServiceStatisticsParams) (AllServiceStatisticsRow, error) {
|
||
row := q.db.QueryRowContext(ctx, allServiceStatistics, arg.ToTimestamp, arg.ToTimestamp_2)
|
||
var i AllServiceStatisticsRow
|
||
err := row.Scan(&i.Registrations, &i.Quizes, &i.Results)
|
||
return i, err
|
||
}
|
||
|
||
const archiveQuiz = `-- name: ArchiveQuiz :exec
|
||
UPDATE quiz SET archived = true WHERE id=$1 AND accountId=$2
|
||
`
|
||
|
||
type ArchiveQuizParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) ArchiveQuiz(ctx context.Context, arg ArchiveQuizParams) error {
|
||
_, err := q.db.ExecContext(ctx, archiveQuiz, arg.ID, arg.Accountid)
|
||
return err
|
||
}
|
||
|
||
const changeQuizSettings = `-- name: ChangeQuizSettings :one
|
||
UPDATE rules
|
||
SET PerformerID = $1,PipelineID = $2,StepID = $3,FieldsRule = $4, TagsToAdd=$5, Deleted = false
|
||
WHERE AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $6 AND accountsAmo.Deleted = false) AND QuizID = $7
|
||
RETURNING id
|
||
`
|
||
|
||
type ChangeQuizSettingsParams struct {
|
||
Performerid int32 `db:"performerid" json:"performerid"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
Stepid int32 `db:"stepid" json:"stepid"`
|
||
Fieldsrule json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
|
||
Tagstoadd json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Quizid int32 `db:"quizid" json:"quizid"`
|
||
}
|
||
|
||
func (q *Queries) ChangeQuizSettings(ctx context.Context, arg ChangeQuizSettingsParams) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, changeQuizSettings,
|
||
arg.Performerid,
|
||
arg.Pipelineid,
|
||
arg.Stepid,
|
||
arg.Fieldsrule,
|
||
arg.Tagstoadd,
|
||
arg.Accountid,
|
||
arg.Quizid,
|
||
)
|
||
var id int64
|
||
err := row.Scan(&id)
|
||
return id, err
|
||
}
|
||
|
||
const checkAndAddDefault = `-- name: CheckAndAddDefault :exec
|
||
UPDATE privileges
|
||
SET amount = $1, created_at = NOW()
|
||
WHERE privilege_name = $2
|
||
AND (amount < $3 OR created_at <= NOW() - INTERVAL '1 month')
|
||
`
|
||
|
||
type CheckAndAddDefaultParams struct {
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount_2 sql.NullInt32 `db:"amount_2" json:"amount_2"`
|
||
}
|
||
|
||
func (q *Queries) CheckAndAddDefault(ctx context.Context, arg CheckAndAddDefaultParams) error {
|
||
_, err := q.db.ExecContext(ctx, checkAndAddDefault, arg.Amount, arg.PrivilegeName, arg.Amount_2)
|
||
return err
|
||
}
|
||
|
||
const checkExpiredToken = `-- name: CheckExpiredToken :one
|
||
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM tokens WHERE AccountID = $1 AND Expiration <= NOW()
|
||
`
|
||
|
||
func (q *Queries) CheckExpiredToken(ctx context.Context, accountid string) (Token, error) {
|
||
row := q.db.QueryRowContext(ctx, checkExpiredToken, accountid)
|
||
var i Token
|
||
err := row.Scan(
|
||
&i.Accountid,
|
||
&i.Refreshtoken,
|
||
&i.Accesstoken,
|
||
&i.Authcode,
|
||
&i.Expiration,
|
||
&i.Createdat,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const checkFields = `-- name: CheckFields :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
), new_fields AS (
|
||
SELECT (field->>'AmoID')::INT AS amoID,
|
||
COALESCE(field->>'Code', '')::varchar(255) AS code,
|
||
COALESCE(field->>'Name', '')::varchar(512) AS name,
|
||
CAST(field->>'Entity' AS entitytype) AS Entity,
|
||
COALESCE(field->>'Type', '')::fieldtype AS type,
|
||
CURRENT_TIMESTAMP AS createdAt
|
||
FROM json_array_elements($2::json) AS field
|
||
), inserted_fields AS(
|
||
INSERT INTO fields (amoID, code, accountID, name, Entity, type, createdAt)
|
||
SELECT nf.amoID,
|
||
nf.code,
|
||
ud.AmoID,
|
||
nf.name,
|
||
nf.Entity,
|
||
nf.type,
|
||
nf.createdAt
|
||
FROM new_fields nf
|
||
JOIN user_data ud ON true
|
||
ON CONFLICT (amoID, accountID, entity) DO UPDATE SET Deleted=false
|
||
RETURNING id, amoid, code, accountid, name, entity, type, deleted, createdat
|
||
)
|
||
SELECT nf.amoid, nf.code, nf.name, nf.entity, nf.type, nf.createdat,ud.AmoID
|
||
FROM new_fields nf
|
||
JOIN user_data ud ON true
|
||
WHERE NOT EXISTS (
|
||
SELECT id, ins.amoid, code, accountid, name, entity, type, deleted, createdat, ud.amoid
|
||
FROM inserted_fields ins
|
||
JOIN user_data ud ON true
|
||
WHERE ins.amoID = nf.amoID AND ins.accountID = ud.amoid AND ins.Entity = nf.Entity
|
||
)
|
||
`
|
||
|
||
type CheckFieldsParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 json.RawMessage `db:"column_2" json:"column_2"`
|
||
}
|
||
|
||
type CheckFieldsRow struct {
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Code string `db:"code" json:"code"`
|
||
Name string `db:"name" json:"name"`
|
||
Entity interface{} `db:"entity" json:"entity"`
|
||
Type interface{} `db:"type" json:"type"`
|
||
Createdat interface{} `db:"createdat" json:"createdat"`
|
||
Amoid_2 int32 `db:"amoid_2" json:"amoid_2"`
|
||
}
|
||
|
||
func (q *Queries) CheckFields(ctx context.Context, arg CheckFieldsParams) ([]CheckFieldsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, checkFields, arg.Accountid, arg.Column2)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []CheckFieldsRow
|
||
for rows.Next() {
|
||
var i CheckFieldsRow
|
||
if err := rows.Scan(
|
||
&i.Amoid,
|
||
&i.Code,
|
||
&i.Name,
|
||
&i.Entity,
|
||
&i.Type,
|
||
&i.Createdat,
|
||
&i.Amoid_2,
|
||
); 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 checkPipelines = `-- name: CheckPipelines :many
|
||
WITH new_pipelines AS (
|
||
SELECT (pipeline->>'AmoID')::INT AS amoID,
|
||
(pipeline->>'AccountID')::INT AS accountID,
|
||
COALESCE(pipeline->>'Name', '')::varchar(512) AS name,
|
||
CASE WHEN (pipeline->>'IsArchive') = 'true' THEN TRUE ELSE FALSE END AS isArchive,
|
||
CURRENT_TIMESTAMP AS createdAt
|
||
FROM json_array_elements($1::json) AS pipeline
|
||
), inserted_pipelines AS(
|
||
INSERT INTO pipelines (amoID, accountID, name, isArchive, createdAt)
|
||
SELECT np.amoID,
|
||
np.accountID,
|
||
np.name,
|
||
np.isArchive,
|
||
np.createdAt
|
||
FROM new_pipelines np
|
||
ON CONFLICT (amoID, accountID) DO NOTHING
|
||
RETURNING id, amoid, accountid, name, isarchive, deleted, createdat
|
||
)
|
||
SELECT np.amoid, np.accountid, np.name, np.isarchive, np.createdat
|
||
FROM new_pipelines np
|
||
WHERE NOT EXISTS (
|
||
SELECT id, amoid, accountid, name, isarchive, deleted, createdat
|
||
FROM inserted_pipelines ins
|
||
WHERE ins.amoID = np.amoID AND ins.accountID = np.accountID
|
||
)
|
||
`
|
||
|
||
type CheckPipelinesRow struct {
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Isarchive bool `db:"isarchive" json:"isarchive"`
|
||
Createdat interface{} `db:"createdat" json:"createdat"`
|
||
}
|
||
|
||
func (q *Queries) CheckPipelines(ctx context.Context, dollar_1 json.RawMessage) ([]CheckPipelinesRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, checkPipelines, dollar_1)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []CheckPipelinesRow
|
||
for rows.Next() {
|
||
var i CheckPipelinesRow
|
||
if err := rows.Scan(
|
||
&i.Amoid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Isarchive,
|
||
&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 checkResultOwner = `-- name: CheckResultOwner :one
|
||
SELECT q.accountid FROM answer a JOIN quiz q ON a.quiz_id = q.id WHERE a.id = $1 AND a.deleted = FALSE AND a.start = false
|
||
`
|
||
|
||
func (q *Queries) CheckResultOwner(ctx context.Context, id int64) (string, error) {
|
||
row := q.db.QueryRowContext(ctx, checkResultOwner, id)
|
||
var accountid string
|
||
err := row.Scan(&accountid)
|
||
return accountid, err
|
||
}
|
||
|
||
const checkResultsOwner = `-- name: CheckResultsOwner :many
|
||
SELECT a.id
|
||
FROM answer a
|
||
JOIN quiz q ON a.quiz_id = q.id
|
||
WHERE a.id = ANY($1::bigint[]) AND a.deleted = FALSE AND q.accountid = $2 AND a.start = false
|
||
`
|
||
|
||
type CheckResultsOwnerParams struct {
|
||
Column1 []int64 `db:"column_1" json:"column_1"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) CheckResultsOwner(ctx context.Context, arg CheckResultsOwnerParams) ([]int64, error) {
|
||
rows, err := q.db.QueryContext(ctx, checkResultsOwner, pq.Array(arg.Column1), arg.Accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []int64
|
||
for rows.Next() {
|
||
var id int64
|
||
if err := rows.Scan(&id); err != nil {
|
||
return nil, err
|
||
}
|
||
items = append(items, id)
|
||
}
|
||
if err := rows.Close(); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
return items, nil
|
||
}
|
||
|
||
const checkSteps = `-- name: CheckSteps :many
|
||
WITH new_steps AS (
|
||
SELECT (step->>'AmoID')::INT AS amoID,
|
||
(step->>'PipelineID')::INT AS pipelineID,
|
||
(step->>'AccountID')::INT AS accountID,
|
||
COALESCE(step->>'Name', '')::varchar(512) AS name,
|
||
COALESCE(step->>'Color', '')::varchar(50) AS color,
|
||
CURRENT_TIMESTAMP AS createdAt
|
||
FROM json_array_elements($1::json) AS step
|
||
), inserted_steps AS (
|
||
INSERT INTO steps (amoID, pipelineID, accountID, name, color, createdAt)
|
||
SELECT ns.amoID,
|
||
ns.pipelineID,
|
||
ns.accountID,
|
||
ns.name,
|
||
ns.color,
|
||
ns.createdAt
|
||
FROM new_steps ns
|
||
ON CONFLICT (amoID, accountID, PipelineID) DO NOTHING
|
||
RETURNING id, amoid, pipelineid, accountid, name, color, deleted, createdat
|
||
)
|
||
SELECT ns.amoid, ns.pipelineid, ns.accountid, ns.name, ns.color, ns.createdat
|
||
FROM new_steps ns
|
||
WHERE NOT EXISTS (
|
||
SELECT id, amoid, pipelineid, accountid, name, color, deleted, createdat
|
||
FROM inserted_steps ins
|
||
WHERE ins.amoID = ns.amoID AND ins.accountID = ns.accountID AND ins.pipelineID = ns.pipelineID
|
||
)
|
||
`
|
||
|
||
type CheckStepsRow struct {
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Color string `db:"color" json:"color"`
|
||
Createdat interface{} `db:"createdat" json:"createdat"`
|
||
}
|
||
|
||
func (q *Queries) CheckSteps(ctx context.Context, dollar_1 json.RawMessage) ([]CheckStepsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, checkSteps, dollar_1)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []CheckStepsRow
|
||
for rows.Next() {
|
||
var i CheckStepsRow
|
||
if err := rows.Scan(
|
||
&i.Amoid,
|
||
&i.Pipelineid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Color,
|
||
&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 checkTags = `-- name: CheckTags :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
), new_tags AS (
|
||
SELECT (tag->>'AmoID')::INT AS amoID,
|
||
(tag->>'Entity')::entitytype AS Entity,
|
||
COALESCE(tag->>'Name', '')::VARCHAR(512) AS name,
|
||
COALESCE(tag->>'Color', '')::VARCHAR(50) AS color
|
||
FROM json_array_elements($2::json) AS tag
|
||
), inserted_tags AS (
|
||
INSERT INTO tags (amoID, accountID, Entity, name, color, createdAt)
|
||
SELECT nt.amoID,
|
||
ud.AmoID,
|
||
nt.Entity,
|
||
nt.name,
|
||
nt.color,
|
||
CURRENT_TIMESTAMP
|
||
FROM new_tags nt
|
||
JOIN user_data ud ON true
|
||
ON CONFLICT (amoID, accountID, Entity) DO UPDATE SET Deleted = false
|
||
RETURNING id, amoid, accountid, entity, name, color, deleted, createdat
|
||
)
|
||
SELECT nt.amoid, nt.entity, nt.name, nt.color,ud.AmoID
|
||
FROM new_tags nt
|
||
JOIN user_data ud ON true
|
||
WHERE NOT EXISTS (
|
||
SELECT id, ins.amoid, accountid, entity, name, color, deleted, createdat, ud.amoid
|
||
FROM inserted_tags ins
|
||
JOIN user_data ud ON true
|
||
WHERE ins.amoID = nt.amoID AND ins.accountID = ud.amoid AND ins.Entity = nt.Entity
|
||
)
|
||
`
|
||
|
||
type CheckTagsParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 json.RawMessage `db:"column_2" json:"column_2"`
|
||
}
|
||
|
||
type CheckTagsRow struct {
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Entity interface{} `db:"entity" json:"entity"`
|
||
Name string `db:"name" json:"name"`
|
||
Color string `db:"color" json:"color"`
|
||
Amoid_2 int32 `db:"amoid_2" json:"amoid_2"`
|
||
}
|
||
|
||
func (q *Queries) CheckTags(ctx context.Context, arg CheckTagsParams) ([]CheckTagsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, checkTags, arg.Accountid, arg.Column2)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []CheckTagsRow
|
||
for rows.Next() {
|
||
var i CheckTagsRow
|
||
if err := rows.Scan(
|
||
&i.Amoid,
|
||
&i.Entity,
|
||
&i.Name,
|
||
&i.Color,
|
||
&i.Amoid_2,
|
||
); 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 copyQuestion = `-- name: CopyQuestion :one
|
||
INSERT INTO question(
|
||
quiz_id, title, description, questiontype, required,
|
||
page, content, version, parent_ids
|
||
)
|
||
SELECT $1, title, description, questiontype, required,
|
||
page, content, version, parent_ids
|
||
FROM question WHERE question.id=$2
|
||
RETURNING question.id, quiz_id, created_at, updated_at
|
||
`
|
||
|
||
type CopyQuestionParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
ID int64 `db:"id" json:"id"`
|
||
}
|
||
|
||
type CopyQuestionRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
}
|
||
|
||
func (q *Queries) CopyQuestion(ctx context.Context, arg CopyQuestionParams) (CopyQuestionRow, error) {
|
||
row := q.db.QueryRowContext(ctx, copyQuestion, arg.QuizID, arg.ID)
|
||
var i CopyQuestionRow
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const copyQuestionQuizID = `-- name: CopyQuestionQuizID :exec
|
||
INSERT INTO question (
|
||
quiz_id, title, description, questiontype, required,
|
||
page, content, version, parent_ids, created_at, updated_at
|
||
)
|
||
SELECT
|
||
$2, title, description, questiontype, required,
|
||
page, content, version, parent_ids, created_at, updated_at
|
||
FROM
|
||
question
|
||
WHERE
|
||
question.quiz_id = $1 AND deleted = false
|
||
`
|
||
|
||
type CopyQuestionQuizIDParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
QuizID_2 int64 `db:"quiz_id_2" json:"quiz_id_2"`
|
||
}
|
||
|
||
func (q *Queries) CopyQuestionQuizID(ctx context.Context, arg CopyQuestionQuizIDParams) error {
|
||
_, err := q.db.ExecContext(ctx, copyQuestionQuizID, arg.QuizID, arg.QuizID_2)
|
||
return err
|
||
}
|
||
|
||
const copyQuiz = `-- name: CopyQuiz :one
|
||
INSERT INTO quiz(
|
||
accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
|
||
status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count, super, group_id
|
||
)
|
||
SELECT accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
|
||
status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count, super, group_id
|
||
FROM quiz WHERE quiz.id=$1 AND quiz.accountId=$2
|
||
RETURNING id, qid,created_at, updated_at
|
||
`
|
||
|
||
type CopyQuizParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
type CopyQuizRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
}
|
||
|
||
func (q *Queries) CopyQuiz(ctx context.Context, arg CopyQuizParams) (CopyQuizRow, error) {
|
||
row := q.db.QueryRowContext(ctx, copyQuiz, arg.ID, arg.Accountid)
|
||
var i CopyQuizRow
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Qid,
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const copyQuizQuestions = `-- name: CopyQuizQuestions :exec
|
||
INSERT INTO question(
|
||
quiz_id, title, description, questiontype, required, page, content, version, parent_ids
|
||
)
|
||
SELECT $2, title, description, questiontype, required, page, content, version, parent_ids
|
||
FROM question WHERE question.quiz_id=$1 AND deleted=false
|
||
`
|
||
|
||
type CopyQuizQuestionsParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
QuizID_2 int64 `db:"quiz_id_2" json:"quiz_id_2"`
|
||
}
|
||
|
||
func (q *Queries) CopyQuizQuestions(ctx context.Context, arg CopyQuizQuestionsParams) error {
|
||
_, err := q.db.ExecContext(ctx, copyQuizQuestions, arg.QuizID, arg.QuizID_2)
|
||
return err
|
||
}
|
||
|
||
const createAccount = `-- name: CreateAccount :one
|
||
INSERT INTO account (id, user_id, email, created_at, deleted) VALUES ($1, $2, $3, $4, $5) RETURNING id, user_id, email, created_at, deleted
|
||
`
|
||
|
||
type CreateAccountParams struct {
|
||
ID uuid.UUID `db:"id" json:"id"`
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
Email sql.NullString `db:"email" json:"email"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
Deleted sql.NullBool `db:"deleted" json:"deleted"`
|
||
}
|
||
|
||
func (q *Queries) CreateAccount(ctx context.Context, arg CreateAccountParams) (Account, error) {
|
||
row := q.db.QueryRowContext(ctx, createAccount,
|
||
arg.ID,
|
||
arg.UserID,
|
||
arg.Email,
|
||
arg.CreatedAt,
|
||
arg.Deleted,
|
||
)
|
||
var i Account
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.UserID,
|
||
&i.Email,
|
||
&i.CreatedAt,
|
||
&i.Deleted,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const createAmoAccount = `-- name: CreateAmoAccount :exec
|
||
|
||
INSERT INTO accountsAmo (AccountID, AmoID,Name, Subdomain, Country,DriveURL)
|
||
VALUES ($1, $2, $3, $4, $5, $6)
|
||
`
|
||
|
||
type CreateAmoAccountParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Name string `db:"name" json:"name"`
|
||
Subdomain string `db:"subdomain" json:"subdomain"`
|
||
Country string `db:"country" json:"country"`
|
||
Driveurl string `db:"driveurl" json:"driveurl"`
|
||
}
|
||
|
||
// amo methods:
|
||
func (q *Queries) CreateAmoAccount(ctx context.Context, arg CreateAmoAccountParams) error {
|
||
_, err := q.db.ExecContext(ctx, createAmoAccount,
|
||
arg.Accountid,
|
||
arg.Amoid,
|
||
arg.Name,
|
||
arg.Subdomain,
|
||
arg.Country,
|
||
arg.Driveurl,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const createQuizAudience = `-- name: CreateQuizAudience :one
|
||
INSERT INTO gigachatAudience (QuizID, Sex, Age) VALUES ($1, $2, $3) RETURNING ID
|
||
`
|
||
|
||
type CreateQuizAudienceParams struct {
|
||
Quizid int64 `db:"quizid" json:"quizid"`
|
||
Sex bool `db:"sex" json:"sex"`
|
||
Age string `db:"age" json:"age"`
|
||
}
|
||
|
||
func (q *Queries) CreateQuizAudience(ctx context.Context, arg CreateQuizAudienceParams) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, createQuizAudience, arg.Quizid, arg.Sex, arg.Age)
|
||
var id int64
|
||
err := row.Scan(&id)
|
||
return id, err
|
||
}
|
||
|
||
const createWebHook = `-- name: CreateWebHook :exec
|
||
INSERT INTO tokens (AccountID, RefreshToken, AccessToken, AuthCode, Expiration, CreatedAt)
|
||
VALUES ($1, $2, $3, $4, $5, $6)
|
||
`
|
||
|
||
type CreateWebHookParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Refreshtoken string `db:"refreshtoken" json:"refreshtoken"`
|
||
Accesstoken string `db:"accesstoken" json:"accesstoken"`
|
||
Authcode string `db:"authcode" json:"authcode"`
|
||
Expiration time.Time `db:"expiration" json:"expiration"`
|
||
Createdat sql.NullTime `db:"createdat" json:"createdat"`
|
||
}
|
||
|
||
func (q *Queries) CreateWebHook(ctx context.Context, arg CreateWebHookParams) error {
|
||
_, err := q.db.ExecContext(ctx, createWebHook,
|
||
arg.Accountid,
|
||
arg.Refreshtoken,
|
||
arg.Accesstoken,
|
||
arg.Authcode,
|
||
arg.Expiration,
|
||
arg.Createdat,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const decrementManual = `-- name: DecrementManual :one
|
||
UPDATE privileges p SET amount = amount - 1 FROM account a
|
||
WHERE p.account_id = a.id AND a.user_id = $1 AND p.privilegeID = $2 AND p.amount > 0
|
||
RETURNING p.id, p.privilegeID, p.account_id, p.privilege_name, p.amount, p.created_at
|
||
`
|
||
|
||
type DecrementManualParams struct {
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
}
|
||
|
||
func (q *Queries) DecrementManual(ctx context.Context, arg DecrementManualParams) (Privilege, error) {
|
||
row := q.db.QueryRowContext(ctx, decrementManual, arg.UserID, arg.Privilegeid)
|
||
var i Privilege
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Privilegeid,
|
||
&i.AccountID,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&i.CreatedAt,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const deleteAccountById = `-- name: DeleteAccountById :exec
|
||
DELETE FROM account WHERE id = $1
|
||
`
|
||
|
||
func (q *Queries) DeleteAccountById(ctx context.Context, id uuid.UUID) error {
|
||
_, err := q.db.ExecContext(ctx, deleteAccountById, id)
|
||
return err
|
||
}
|
||
|
||
const deleteFields = `-- name: DeleteFields :exec
|
||
UPDATE fields SET Deleted = true WHERE ID = ANY($1::bigint[])
|
||
`
|
||
|
||
func (q *Queries) DeleteFields(ctx context.Context, dollar_1 []int64) error {
|
||
_, err := q.db.ExecContext(ctx, deleteFields, pq.Array(dollar_1))
|
||
return err
|
||
}
|
||
|
||
const deletePipelines = `-- name: DeletePipelines :exec
|
||
UPDATE pipelines SET Deleted = true WHERE ID = ANY($1::bigint[])
|
||
`
|
||
|
||
func (q *Queries) DeletePipelines(ctx context.Context, dollar_1 []int64) error {
|
||
_, err := q.db.ExecContext(ctx, deletePipelines, pq.Array(dollar_1))
|
||
return err
|
||
}
|
||
|
||
const deletePrivilegeByAccID = `-- name: DeletePrivilegeByAccID :exec
|
||
DELETE FROM privileges WHERE account_id = $1
|
||
`
|
||
|
||
func (q *Queries) DeletePrivilegeByAccID(ctx context.Context, accountID uuid.NullUUID) error {
|
||
_, err := q.db.ExecContext(ctx, deletePrivilegeByAccID, accountID)
|
||
return err
|
||
}
|
||
|
||
const deletePrivilegeByID = `-- name: DeletePrivilegeByID :exec
|
||
DELETE FROM privileges WHERE id = $1
|
||
`
|
||
|
||
func (q *Queries) DeletePrivilegeByID(ctx context.Context, id int32) error {
|
||
_, err := q.db.ExecContext(ctx, deletePrivilegeByID, id)
|
||
return err
|
||
}
|
||
|
||
const deleteQuestion = `-- name: DeleteQuestion :one
|
||
UPDATE question SET deleted=true WHERE id=$1 RETURNING question.id, question.quiz_id, question.title, question.description, question.questiontype, question.required, question.deleted, question.page, question.content, question.version, question.parent_ids, question.created_at, question.updated_at, question.session
|
||
`
|
||
|
||
func (q *Queries) DeleteQuestion(ctx context.Context, id int64) (Question, error) {
|
||
row := q.db.QueryRowContext(ctx, deleteQuestion, id)
|
||
var i Question
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.Title,
|
||
&i.Description,
|
||
&i.Questiontype,
|
||
&i.Required,
|
||
&i.Deleted,
|
||
&i.Page,
|
||
&i.Content,
|
||
&i.Version,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.Session,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const deleteQuizAudience = `-- name: DeleteQuizAudience :exec
|
||
UPDATE gigachatAudience set Deleted = TRUE WHERE QuizID = $1
|
||
`
|
||
|
||
func (q *Queries) DeleteQuizAudience(ctx context.Context, quizid int64) error {
|
||
_, err := q.db.ExecContext(ctx, deleteQuizAudience, quizid)
|
||
return err
|
||
}
|
||
|
||
const deleteQuizByID = `-- name: DeleteQuizByID :one
|
||
UPDATE quiz SET deleted=true WHERE quiz.id=$1 AND accountid=$2 RETURNING quiz.id, quiz.qid, quiz.accountid, quiz.deleted, quiz.archived, quiz.fingerprinting, quiz.repeatable, quiz.note_prevented, quiz.mail_notifications, quiz.unique_answers, quiz.super, quiz.group_id, quiz.name, quiz.description, quiz.config, quiz.status, quiz.limit_answers, quiz.due_to, quiz.time_of_passing, quiz.pausable, quiz.version, quiz.version_comment, quiz.parent_ids, quiz.created_at, quiz.updated_at, quiz.questions_count, quiz.answers_count, quiz.average_time_passing, quiz.sessions_count
|
||
`
|
||
|
||
type DeleteQuizByIDParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) DeleteQuizByID(ctx context.Context, arg DeleteQuizByIDParams) (Quiz, error) {
|
||
row := q.db.QueryRowContext(ctx, deleteQuizByID, arg.ID, arg.Accountid)
|
||
var i Quiz
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Qid,
|
||
&i.Accountid,
|
||
&i.Deleted,
|
||
&i.Archived,
|
||
&i.Fingerprinting,
|
||
&i.Repeatable,
|
||
&i.NotePrevented,
|
||
&i.MailNotifications,
|
||
&i.UniqueAnswers,
|
||
&i.Super,
|
||
&i.GroupID,
|
||
&i.Name,
|
||
&i.Description,
|
||
&i.Config,
|
||
&i.Status,
|
||
&i.LimitAnswers,
|
||
&i.DueTo,
|
||
&i.TimeOfPassing,
|
||
&i.Pausable,
|
||
&i.Version,
|
||
&i.VersionComment,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.QuestionsCount,
|
||
&i.AnswersCount,
|
||
&i.AverageTimePassing,
|
||
&i.SessionsCount,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const deleteSteps = `-- name: DeleteSteps :exec
|
||
UPDATE steps SET Deleted = true WHERE ID = ANY($1::bigint[])
|
||
`
|
||
|
||
func (q *Queries) DeleteSteps(ctx context.Context, dollar_1 []int64) error {
|
||
_, err := q.db.ExecContext(ctx, deleteSteps, pq.Array(dollar_1))
|
||
return err
|
||
}
|
||
|
||
const deleteTags = `-- name: DeleteTags :exec
|
||
UPDATE tags SET Deleted = true WHERE ID = ANY($1::bigint[])
|
||
`
|
||
|
||
func (q *Queries) DeleteTags(ctx context.Context, dollar_1 []int64) error {
|
||
_, err := q.db.ExecContext(ctx, deleteTags, pq.Array(dollar_1))
|
||
return err
|
||
}
|
||
|
||
const deleteUsers = `-- name: DeleteUsers :exec
|
||
UPDATE usersAmo SET Deleted = true WHERE ID = ANY($1::bigint[])
|
||
`
|
||
|
||
func (q *Queries) DeleteUsers(ctx context.Context, dollar_1 []int64) error {
|
||
_, err := q.db.ExecContext(ctx, deleteUsers, pq.Array(dollar_1))
|
||
return err
|
||
}
|
||
|
||
const deviceStatistics = `-- name: DeviceStatistics :many
|
||
WITH DeviceStats AS (
|
||
SELECT
|
||
device_type,
|
||
COUNT(*) AS device_count
|
||
FROM
|
||
answer
|
||
WHERE
|
||
answer.quiz_id = $1
|
||
AND created_at >= to_timestamp($2)
|
||
AND created_at <= to_timestamp($3)
|
||
AND result = TRUE
|
||
GROUP BY
|
||
device_type
|
||
),
|
||
OSStats AS (
|
||
SELECT
|
||
os,
|
||
COUNT(*) AS os_count
|
||
FROM
|
||
answer
|
||
WHERE
|
||
answer.quiz_id = $1
|
||
AND created_at >= to_timestamp($2)
|
||
AND created_at <= to_timestamp($3)
|
||
AND result = TRUE
|
||
GROUP BY
|
||
os
|
||
),
|
||
BrowserStats AS (
|
||
SELECT
|
||
browser,
|
||
COUNT(*) AS browser_count
|
||
FROM
|
||
answer
|
||
WHERE
|
||
answer.quiz_id = $1
|
||
AND created_at >= to_timestamp($2)
|
||
AND created_at <= to_timestamp($3)
|
||
AND result = TRUE
|
||
GROUP BY
|
||
browser
|
||
),
|
||
TotalStats AS (
|
||
SELECT
|
||
COUNT(*) AS total_count
|
||
FROM
|
||
answer
|
||
WHERE
|
||
answer.quiz_id = $1
|
||
AND created_at >= to_timestamp($2)
|
||
AND created_at <= to_timestamp($3)
|
||
AND result = TRUE
|
||
)
|
||
SELECT
|
||
DeviceStats.device_type,
|
||
CAST((DeviceStats.device_count::FLOAT / TotalStats.total_count) * 100.0 AS FLOAT8) AS device_percentage,
|
||
OSStats.os,
|
||
CAST((OSStats.os_count::FLOAT / TotalStats.total_count) * 100.0 AS FLOAT8) AS os_percentage,
|
||
BrowserStats.browser,
|
||
CAST((BrowserStats.browser_count::FLOAT / TotalStats.total_count) * 100.0 AS FLOAT8) AS browser_percentage
|
||
FROM
|
||
DeviceStats,
|
||
OSStats,
|
||
BrowserStats,
|
||
TotalStats
|
||
`
|
||
|
||
type DeviceStatisticsParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
ToTimestamp float64 `db:"to_timestamp" json:"to_timestamp"`
|
||
ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
|
||
}
|
||
|
||
type DeviceStatisticsRow struct {
|
||
DeviceType string `db:"device_type" json:"device_type"`
|
||
DevicePercentage float64 `db:"device_percentage" json:"device_percentage"`
|
||
Os string `db:"os" json:"os"`
|
||
OsPercentage float64 `db:"os_percentage" json:"os_percentage"`
|
||
Browser string `db:"browser" json:"browser"`
|
||
BrowserPercentage float64 `db:"browser_percentage" json:"browser_percentage"`
|
||
}
|
||
|
||
func (q *Queries) DeviceStatistics(ctx context.Context, arg DeviceStatisticsParams) ([]DeviceStatisticsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, deviceStatistics, arg.QuizID, arg.ToTimestamp, arg.ToTimestamp_2)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []DeviceStatisticsRow
|
||
for rows.Next() {
|
||
var i DeviceStatisticsRow
|
||
if err := rows.Scan(
|
||
&i.DeviceType,
|
||
&i.DevicePercentage,
|
||
&i.Os,
|
||
&i.OsPercentage,
|
||
&i.Browser,
|
||
&i.BrowserPercentage,
|
||
); 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 duplicateQuestion = `-- name: DuplicateQuestion :one
|
||
INSERT INTO question(
|
||
quiz_id, title, description, questiontype, required,
|
||
page, content, version, parent_ids
|
||
)
|
||
SELECT quiz_id, title, description, questiontype, required,
|
||
page, content, version, parent_ids
|
||
FROM question WHERE question.id=$1
|
||
RETURNING question.id, quiz_id, created_at, updated_at
|
||
`
|
||
|
||
type DuplicateQuestionRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
}
|
||
|
||
func (q *Queries) DuplicateQuestion(ctx context.Context, id int64) (DuplicateQuestionRow, error) {
|
||
row := q.db.QueryRowContext(ctx, duplicateQuestion, id)
|
||
var i DuplicateQuestionRow
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const generalStatistics = `-- name: GeneralStatistics :many
|
||
WITH TimeBucket AS (
|
||
SELECT
|
||
date_trunc('hour', timestamp_bucket)::TIMESTAMP AS time_interval_start,
|
||
COALESCE(LEAD(
|
||
date_trunc('hour', timestamp_bucket)::TIMESTAMP
|
||
) OVER (ORDER BY timestamp_bucket), NOW()) AS time_interval_end
|
||
FROM
|
||
generate_series(TO_TIMESTAMP($1), TO_TIMESTAMP($2), CASE
|
||
WHEN EXTRACT(epoch FROM TO_TIMESTAMP($2)) - EXTRACT(epoch FROM TO_TIMESTAMP($1)) > 172800 THEN '1 day'::interval
|
||
ELSE '1 hour'::interval
|
||
END) AS timestamp_bucket
|
||
),
|
||
OpenStats AS (
|
||
SELECT
|
||
tb.time_interval_start,
|
||
tb.time_interval_end,
|
||
COUNT(DISTINCT session) AS open_count
|
||
FROM
|
||
(
|
||
SELECT
|
||
session,
|
||
MIN(created_at) AS first_start_time
|
||
FROM
|
||
answer
|
||
WHERE
|
||
answer.quiz_id = $3
|
||
AND start = TRUE
|
||
AND created_at >= TO_TIMESTAMP($1)
|
||
AND created_at <= TO_TIMESTAMP($2)
|
||
GROUP BY
|
||
session
|
||
) AS first_starts
|
||
JOIN TimeBucket tb ON date_trunc('hour', first_starts.first_start_time) >= tb.time_interval_start
|
||
AND date_trunc('hour', first_starts.first_start_time) < tb.time_interval_end
|
||
GROUP BY
|
||
tb.time_interval_start, tb.time_interval_end
|
||
),
|
||
ResultStats AS (
|
||
SELECT
|
||
tb.time_interval_start,
|
||
tb.time_interval_end,
|
||
COUNT(DISTINCT session) AS true_result_count
|
||
FROM
|
||
(
|
||
SELECT
|
||
session,
|
||
MIN(created_at) AS first_result_time
|
||
FROM
|
||
answer
|
||
WHERE
|
||
answer.quiz_id = $3
|
||
AND result = TRUE
|
||
AND created_at >= TO_TIMESTAMP($1)
|
||
AND created_at <= TO_TIMESTAMP($2)
|
||
GROUP BY
|
||
session
|
||
) AS first_results
|
||
JOIN TimeBucket tb ON date_trunc('hour', first_results.first_result_time) >= tb.time_interval_start
|
||
AND date_trunc('hour', first_results.first_result_time) < tb.time_interval_end
|
||
GROUP BY
|
||
tb.time_interval_start, tb.time_interval_end
|
||
),
|
||
AvTimeStats AS (
|
||
SELECT
|
||
tb.time_interval_start,
|
||
tb.time_interval_end,
|
||
AVG(EXTRACT(epoch FROM (a.created_at)) - EXTRACT(epoch FROM (b.created_at))) AS avg_time
|
||
FROM
|
||
answer a
|
||
JOIN answer b ON a.session = b.session
|
||
JOIN TimeBucket tb ON date_trunc('hour', a.created_at) >= tb.time_interval_start
|
||
AND date_trunc('hour', a.created_at) < tb.time_interval_end
|
||
WHERE
|
||
a.quiz_id = $3
|
||
AND a.result = TRUE
|
||
AND b.start = TRUE
|
||
AND b.quiz_id = $3
|
||
AND a.created_at >= TO_TIMESTAMP($1)
|
||
AND a.created_at <= TO_TIMESTAMP($2)
|
||
AND b.created_at >= TO_TIMESTAMP($1)
|
||
AND b.created_at <= TO_TIMESTAMP($2)
|
||
GROUP BY
|
||
tb.time_interval_start, tb.time_interval_end
|
||
)
|
||
SELECT
|
||
tb.time_interval_start AS time_bucket,
|
||
COALESCE(os.open_count, 0) AS open_count,
|
||
COALESCE(rs.true_result_count, 0) AS true_result_count,
|
||
CASE
|
||
WHEN COALESCE(os.open_count, 0) > 0 THEN COALESCE(rs.true_result_count, 0)::float / COALESCE(os.open_count, 0)::float
|
||
ELSE 0
|
||
END::float AS conversion,
|
||
COALESCE(at.avg_time, 0) AS avg_time
|
||
FROM
|
||
TimeBucket tb
|
||
LEFT JOIN
|
||
OpenStats os ON tb.time_interval_start = os.time_interval_start
|
||
AND tb.time_interval_end = os.time_interval_end
|
||
LEFT JOIN
|
||
ResultStats rs ON tb.time_interval_start = rs.time_interval_start
|
||
AND tb.time_interval_end = rs.time_interval_end
|
||
LEFT JOIN
|
||
AvTimeStats at ON tb.time_interval_start = at.time_interval_start
|
||
AND tb.time_interval_end = at.time_interval_end
|
||
`
|
||
|
||
type GeneralStatisticsParams struct {
|
||
ToTimestamp float64 `db:"to_timestamp" json:"to_timestamp"`
|
||
ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
}
|
||
|
||
type GeneralStatisticsRow struct {
|
||
TimeBucket time.Time `db:"time_bucket" json:"time_bucket"`
|
||
OpenCount int64 `db:"open_count" json:"open_count"`
|
||
TrueResultCount int64 `db:"true_result_count" json:"true_result_count"`
|
||
Conversion float64 `db:"conversion" json:"conversion"`
|
||
AvgTime float64 `db:"avg_time" json:"avg_time"`
|
||
}
|
||
|
||
func (q *Queries) GeneralStatistics(ctx context.Context, arg GeneralStatisticsParams) ([]GeneralStatisticsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, generalStatistics, arg.ToTimestamp, arg.ToTimestamp_2, arg.QuizID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GeneralStatisticsRow
|
||
for rows.Next() {
|
||
var i GeneralStatisticsRow
|
||
if err := rows.Scan(
|
||
&i.TimeBucket,
|
||
&i.OpenCount,
|
||
&i.TrueResultCount,
|
||
&i.Conversion,
|
||
&i.AvgTime,
|
||
); 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 getAccAndPrivilegeByEmail = `-- name: GetAccAndPrivilegeByEmail :one
|
||
SELECT
|
||
a.id,
|
||
a.user_id,
|
||
a.email,
|
||
a.created_at,
|
||
COALESCE(p.ID,0),
|
||
coalesce(p.privilegeid,''),
|
||
coalesce(p.amount,0),
|
||
coalesce(p.created_at,Now())
|
||
FROM
|
||
account AS a
|
||
LEFT JOIN privileges AS p ON a.id = p.account_id
|
||
WHERE
|
||
a.user_id = $1
|
||
`
|
||
|
||
type GetAccAndPrivilegeByEmailRow struct {
|
||
ID uuid.UUID `db:"id" json:"id"`
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
Email sql.NullString `db:"email" json:"email"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
ID_2 int32 `db:"id_2" json:"id_2"`
|
||
Privilegeid string `db:"privilegeid" json:"privilegeid"`
|
||
Amount int32 `db:"amount" json:"amount"`
|
||
CreatedAt_2 sql.NullTime `db:"created_at_2" json:"created_at_2"`
|
||
}
|
||
|
||
func (q *Queries) GetAccAndPrivilegeByEmail(ctx context.Context, userID sql.NullString) (GetAccAndPrivilegeByEmailRow, error) {
|
||
row := q.db.QueryRowContext(ctx, getAccAndPrivilegeByEmail, userID)
|
||
var i GetAccAndPrivilegeByEmailRow
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.UserID,
|
||
&i.Email,
|
||
&i.CreatedAt,
|
||
&i.ID_2,
|
||
&i.Privilegeid,
|
||
&i.Amount,
|
||
&i.CreatedAt_2,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getAccountWithPrivileges = `-- name: GetAccountWithPrivileges :many
|
||
SELECT a.id, a.user_id, a.created_at, a.deleted,
|
||
coalesce(p.id,0) AS privilege_id,
|
||
coalesce(p.privilegeID,''),
|
||
coalesce(p.privilege_name,''),
|
||
coalesce(p.amount,0), coalesce(p.created_at,Now()) AS privilege_created_at
|
||
FROM account a
|
||
LEFT JOIN privileges AS p ON a.id = p.account_id
|
||
WHERE a.user_id = $1
|
||
`
|
||
|
||
type GetAccountWithPrivilegesRow struct {
|
||
ID uuid.UUID `db:"id" json:"id"`
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
Deleted sql.NullBool `db:"deleted" json:"deleted"`
|
||
PrivilegeID int32 `db:"privilege_id" json:"privilege_id"`
|
||
Privilegeid string `db:"privilegeid" json:"privilegeid"`
|
||
PrivilegeName string `db:"privilege_name" json:"privilege_name"`
|
||
Amount int32 `db:"amount" json:"amount"`
|
||
PrivilegeCreatedAt sql.NullTime `db:"privilege_created_at" json:"privilege_created_at"`
|
||
}
|
||
|
||
func (q *Queries) GetAccountWithPrivileges(ctx context.Context, userID sql.NullString) ([]GetAccountWithPrivilegesRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getAccountWithPrivileges, userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetAccountWithPrivilegesRow
|
||
for rows.Next() {
|
||
var i GetAccountWithPrivilegesRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.UserID,
|
||
&i.CreatedAt,
|
||
&i.Deleted,
|
||
&i.PrivilegeID,
|
||
&i.Privilegeid,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&i.PrivilegeCreatedAt,
|
||
); 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 getAllAnswersByQuizID = `-- name: GetAllAnswersByQuizID :many
|
||
SELECT DISTINCT ON (a.question_id)
|
||
a.content, a.created_at, a.question_id, a.id, q.questiontype::Text as questiontype, quiz.qid
|
||
FROM
|
||
answer a
|
||
JOIN
|
||
question q ON a.question_id = q.id
|
||
JOIN
|
||
quiz ON q.quiz_id = quiz.id
|
||
WHERE
|
||
a.session = $1 AND a.start = false AND a.deleted = false
|
||
ORDER BY
|
||
a.question_id ASC, a.created_at DESC
|
||
`
|
||
|
||
type GetAllAnswersByQuizIDRow struct {
|
||
Content sql.NullString `db:"content" json:"content"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
QuestionID int64 `db:"question_id" json:"question_id"`
|
||
ID int64 `db:"id" json:"id"`
|
||
Questiontype string `db:"questiontype" json:"questiontype"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
}
|
||
|
||
func (q *Queries) GetAllAnswersByQuizID(ctx context.Context, session sql.NullString) ([]GetAllAnswersByQuizIDRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getAllAnswersByQuizID, session)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetAllAnswersByQuizIDRow
|
||
for rows.Next() {
|
||
var i GetAllAnswersByQuizIDRow
|
||
if err := rows.Scan(
|
||
&i.Content,
|
||
&i.CreatedAt,
|
||
&i.QuestionID,
|
||
&i.ID,
|
||
&i.Questiontype,
|
||
&i.Qid,
|
||
); 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 getAllCompanyUsers = `-- name: GetAllCompanyUsers :many
|
||
SELECT id, amoid, amouserid, name, email, role, "Group", deleted, createdat FROM usersamo WHERE amoid = $1 AND deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetAllCompanyUsers(ctx context.Context, amoid int32) ([]Usersamo, error) {
|
||
rows, err := q.db.QueryContext(ctx, getAllCompanyUsers, amoid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Usersamo
|
||
for rows.Next() {
|
||
var i Usersamo
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Amouserid,
|
||
&i.Name,
|
||
&i.Email,
|
||
&i.Role,
|
||
&i.Group,
|
||
&i.Deleted,
|
||
&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 getAllTokens = `-- name: GetAllTokens :many
|
||
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM tokens
|
||
`
|
||
|
||
func (q *Queries) GetAllTokens(ctx context.Context) ([]Token, error) {
|
||
rows, err := q.db.QueryContext(ctx, getAllTokens)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Token
|
||
for rows.Next() {
|
||
var i Token
|
||
if err := rows.Scan(
|
||
&i.Accountid,
|
||
&i.Refreshtoken,
|
||
&i.Accesstoken,
|
||
&i.Authcode,
|
||
&i.Expiration,
|
||
&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 getCurrentCompany = `-- name: GetCurrentCompany :one
|
||
SELECT id, accountid, amoid, name, deleted, createdat, subdomain, country, driveurl FROM accountsAmo WHERE AccountID = $1 AND Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetCurrentCompany(ctx context.Context, accountid string) (Accountsamo, error) {
|
||
row := q.db.QueryRowContext(ctx, getCurrentCompany, accountid)
|
||
var i Accountsamo
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Accountid,
|
||
&i.Amoid,
|
||
&i.Name,
|
||
&i.Deleted,
|
||
&i.Createdat,
|
||
&i.Subdomain,
|
||
&i.Country,
|
||
&i.Driveurl,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getExistingContactAmo = `-- name: GetExistingContactAmo :many
|
||
WITH getAmoID AS (
|
||
SELECT AmoID FROM amoContact WHERE amoContact.AccountID = $1 AND amoContact.Field = ANY($2::text[])
|
||
) SELECT id, accountid, amoid, field FROM amoContact
|
||
WHERE amoContact.AccountID = $1 AND amoContact.AmoID IN (SELECT AmoID FROM getAmoID)
|
||
`
|
||
|
||
type GetExistingContactAmoParams struct {
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Column2 []string `db:"column_2" json:"column_2"`
|
||
}
|
||
|
||
func (q *Queries) GetExistingContactAmo(ctx context.Context, arg GetExistingContactAmoParams) ([]Amocontact, error) {
|
||
rows, err := q.db.QueryContext(ctx, getExistingContactAmo, arg.Accountid, pq.Array(arg.Column2))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Amocontact
|
||
for rows.Next() {
|
||
var i Amocontact
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Accountid,
|
||
&i.Amoid,
|
||
&i.Field,
|
||
); 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 getExpiredCountPrivilege = `-- name: GetExpiredCountPrivilege :many
|
||
SELECT p.id, p.privilegeID, p.privilege_name, p.amount, p.created_at, a.user_id
|
||
FROM privileges p
|
||
JOIN account a ON p.account_id = a.id
|
||
WHERE p.amount = 0
|
||
AND p.privilegeID = $1
|
||
`
|
||
|
||
type GetExpiredCountPrivilegeRow struct {
|
||
ID int32 `db:"id" json:"id"`
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
}
|
||
|
||
func (q *Queries) GetExpiredCountPrivilege(ctx context.Context, privilegeid sql.NullString) ([]GetExpiredCountPrivilegeRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getExpiredCountPrivilege, privilegeid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetExpiredCountPrivilegeRow
|
||
for rows.Next() {
|
||
var i GetExpiredCountPrivilegeRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Privilegeid,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&i.CreatedAt,
|
||
&i.UserID,
|
||
); 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 getExpiredDayPrivilege = `-- name: GetExpiredDayPrivilege :many
|
||
SELECT p.id, p.privilegeID, p.privilege_name, p.amount, p.created_at, a.user_id
|
||
FROM privileges p
|
||
JOIN account a ON p.account_id = a.id
|
||
WHERE p.created_at + p.amount * interval '1 day' < NOW()
|
||
AND p.privilegeID = $1
|
||
`
|
||
|
||
type GetExpiredDayPrivilegeRow struct {
|
||
ID int32 `db:"id" json:"id"`
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UserID sql.NullString `db:"user_id" json:"user_id"`
|
||
}
|
||
|
||
func (q *Queries) GetExpiredDayPrivilege(ctx context.Context, privilegeid sql.NullString) ([]GetExpiredDayPrivilegeRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getExpiredDayPrivilege, privilegeid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetExpiredDayPrivilegeRow
|
||
for rows.Next() {
|
||
var i GetExpiredDayPrivilegeRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Privilegeid,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&i.CreatedAt,
|
||
&i.UserID,
|
||
); 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 getFieldByAmoID = `-- name: GetFieldByAmoID :one
|
||
SELECT id, amoid, code, accountid, name, entity, type, deleted, createdat FROM fields WHERE AmoID = $1 AND Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetFieldByAmoID(ctx context.Context, amoid int32) (Field, error) {
|
||
row := q.db.QueryRowContext(ctx, getFieldByAmoID, amoid)
|
||
var i Field
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Code,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Entity,
|
||
&i.Type,
|
||
&i.Deleted,
|
||
&i.Createdat,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getFieldsCount = `-- name: GetFieldsCount :one
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT COUNT(*) FROM fields f JOIN user_data u ON f.AccountID = u.AmoID WHERE f.Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetFieldsCount(ctx context.Context, accountid string) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, getFieldsCount, accountid)
|
||
var count int64
|
||
err := row.Scan(&count)
|
||
return count, err
|
||
}
|
||
|
||
const getFieldsWithPagination = `-- name: GetFieldsWithPagination :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT f.id, f.amoid, f.code, f.accountid, f.name, f.entity, f.type, f.deleted, f.createdat
|
||
FROM fields f JOIN user_data u ON f.AccountID = u.AmoID
|
||
WHERE f.Deleted = false
|
||
ORDER BY f.ID OFFSET ($2 - 1) * $3 LIMIT $3
|
||
`
|
||
|
||
type GetFieldsWithPaginationParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 interface{} `db:"column_2" json:"column_2"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
}
|
||
|
||
func (q *Queries) GetFieldsWithPagination(ctx context.Context, arg GetFieldsWithPaginationParams) ([]Field, error) {
|
||
rows, err := q.db.QueryContext(ctx, getFieldsWithPagination, arg.Accountid, arg.Column2, arg.Limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Field
|
||
for rows.Next() {
|
||
var i Field
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Code,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Entity,
|
||
&i.Type,
|
||
&i.Deleted,
|
||
&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 getListCreatedQuizzes = `-- name: GetListCreatedQuizzes :many
|
||
SELECT id
|
||
FROM quiz
|
||
WHERE accountid = $1
|
||
`
|
||
|
||
func (q *Queries) GetListCreatedQuizzes(ctx context.Context, accountid string) ([]int64, error) {
|
||
rows, err := q.db.QueryContext(ctx, getListCreatedQuizzes, accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []int64
|
||
for rows.Next() {
|
||
var id int64
|
||
if err := rows.Scan(&id); err != nil {
|
||
return nil, err
|
||
}
|
||
items = append(items, id)
|
||
}
|
||
if err := rows.Close(); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
return items, nil
|
||
}
|
||
|
||
const getListStartQuiz = `-- name: GetListStartQuiz :many
|
||
SELECT id FROM quiz WHERE accountid = $1 AND status = 'start'
|
||
`
|
||
|
||
func (q *Queries) GetListStartQuiz(ctx context.Context, accountid string) ([]int64, error) {
|
||
rows, err := q.db.QueryContext(ctx, getListStartQuiz, accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []int64
|
||
for rows.Next() {
|
||
var id int64
|
||
if err := rows.Scan(&id); err != nil {
|
||
return nil, err
|
||
}
|
||
items = append(items, id)
|
||
}
|
||
if err := rows.Close(); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
return items, nil
|
||
}
|
||
|
||
const getPipelinesCount = `-- name: GetPipelinesCount :one
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT COUNT(*) FROM pipelines p JOIN user_data u ON p.AccountID = u.AmoID WHERE p.Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetPipelinesCount(ctx context.Context, accountid string) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, getPipelinesCount, accountid)
|
||
var count int64
|
||
err := row.Scan(&count)
|
||
return count, err
|
||
}
|
||
|
||
const getPipelinesWithPagination = `-- name: GetPipelinesWithPagination :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT p.id, p.amoid, p.accountid, p.name, p.isarchive, p.deleted, p.createdat
|
||
FROM pipelines p JOIN user_data u ON p.AccountID = u.AmoID
|
||
WHERE p.Deleted = false
|
||
ORDER BY p.ID OFFSET ($2 - 1) * $3 LIMIT $3
|
||
`
|
||
|
||
type GetPipelinesWithPaginationParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 interface{} `db:"column_2" json:"column_2"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
}
|
||
|
||
func (q *Queries) GetPipelinesWithPagination(ctx context.Context, arg GetPipelinesWithPaginationParams) ([]Pipeline, error) {
|
||
rows, err := q.db.QueryContext(ctx, getPipelinesWithPagination, arg.Accountid, arg.Column2, arg.Limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Pipeline
|
||
for rows.Next() {
|
||
var i Pipeline
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Isarchive,
|
||
&i.Deleted,
|
||
&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 getPrivilegesByAccountID = `-- name: GetPrivilegesByAccountID :many
|
||
SELECT id,privilegeID,privilege_name,amount, created_at FROM privileges WHERE account_id = $1
|
||
`
|
||
|
||
type GetPrivilegesByAccountIDRow struct {
|
||
ID int32 `db:"id" json:"id"`
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
}
|
||
|
||
func (q *Queries) GetPrivilegesByAccountID(ctx context.Context, accountID uuid.NullUUID) ([]GetPrivilegesByAccountIDRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getPrivilegesByAccountID, accountID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetPrivilegesByAccountIDRow
|
||
for rows.Next() {
|
||
var i GetPrivilegesByAccountIDRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Privilegeid,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&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 getPrivilegesByAccountIDWC = `-- name: GetPrivilegesByAccountIDWC :many
|
||
SELECT p.id,p.privilegeID,p.privilege_name,p.amount, p.created_at FROM privileges as p JOIN account as a on p.account_id = a.id WHERE a.user_id = $1
|
||
`
|
||
|
||
type GetPrivilegesByAccountIDWCRow struct {
|
||
ID int32 `db:"id" json:"id"`
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
}
|
||
|
||
func (q *Queries) GetPrivilegesByAccountIDWC(ctx context.Context, userID sql.NullString) ([]GetPrivilegesByAccountIDWCRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getPrivilegesByAccountIDWC, userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetPrivilegesByAccountIDWCRow
|
||
for rows.Next() {
|
||
var i GetPrivilegesByAccountIDWCRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Privilegeid,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&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 getPrivilegesQuizAccount = `-- name: GetPrivilegesQuizAccount :many
|
||
SELECT
|
||
p.privilegeID,
|
||
p.privilege_name,
|
||
p.amount,
|
||
p.created_at,
|
||
a.id,
|
||
a.email,
|
||
qz.config
|
||
FROM
|
||
privileges AS p
|
||
INNER JOIN account AS a ON p.account_id = a.id
|
||
INNER JOIN quiz AS qz ON qz.accountid = a.user_id
|
||
WHERE
|
||
qz.id = $1
|
||
`
|
||
|
||
type GetPrivilegesQuizAccountRow struct {
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
ID uuid.UUID `db:"id" json:"id"`
|
||
Email sql.NullString `db:"email" json:"email"`
|
||
Config sql.NullString `db:"config" json:"config"`
|
||
}
|
||
|
||
func (q *Queries) GetPrivilegesQuizAccount(ctx context.Context, id int64) ([]GetPrivilegesQuizAccountRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getPrivilegesQuizAccount, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetPrivilegesQuizAccountRow
|
||
for rows.Next() {
|
||
var i GetPrivilegesQuizAccountRow
|
||
if err := rows.Scan(
|
||
&i.Privilegeid,
|
||
&i.PrivilegeName,
|
||
&i.Amount,
|
||
&i.CreatedAt,
|
||
&i.ID,
|
||
&i.Email,
|
||
&i.Config,
|
||
); 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 getQidOwner = `-- name: GetQidOwner :one
|
||
SELECT accountid FROM quiz where qid=$1
|
||
`
|
||
|
||
func (q *Queries) GetQidOwner(ctx context.Context, qid uuid.NullUUID) (string, error) {
|
||
row := q.db.QueryRowContext(ctx, getQidOwner, qid)
|
||
var accountid string
|
||
err := row.Scan(&accountid)
|
||
return accountid, err
|
||
}
|
||
|
||
const getQuestionHistory = `-- name: GetQuestionHistory :many
|
||
SELECT id, quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids, created_at, updated_at, session FROM question WHERE question.id = $1 OR question.id = ANY(
|
||
SELECT unnest(parent_ids) FROM question WHERE id = $1
|
||
) ORDER BY question.id DESC LIMIT $2 OFFSET $3
|
||
`
|
||
|
||
type GetQuestionHistoryParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
Offset int32 `db:"offset" json:"offset"`
|
||
}
|
||
|
||
func (q *Queries) GetQuestionHistory(ctx context.Context, arg GetQuestionHistoryParams) ([]Question, error) {
|
||
rows, err := q.db.QueryContext(ctx, getQuestionHistory, arg.ID, arg.Limit, arg.Offset)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Question
|
||
for rows.Next() {
|
||
var i Question
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.Title,
|
||
&i.Description,
|
||
&i.Questiontype,
|
||
&i.Required,
|
||
&i.Deleted,
|
||
&i.Page,
|
||
&i.Content,
|
||
&i.Version,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.Session,
|
||
); 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 getQuestionListByIDs = `-- name: GetQuestionListByIDs :many
|
||
SELECT id, quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids, created_at, updated_at, session FROM question WHERE id = ANY($1::int[]) AND deleted = FALSE
|
||
`
|
||
|
||
func (q *Queries) GetQuestionListByIDs(ctx context.Context, dollar_1 []int32) ([]Question, error) {
|
||
rows, err := q.db.QueryContext(ctx, getQuestionListByIDs, pq.Array(dollar_1))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Question
|
||
for rows.Next() {
|
||
var i Question
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.Title,
|
||
&i.Description,
|
||
&i.Questiontype,
|
||
&i.Required,
|
||
&i.Deleted,
|
||
&i.Page,
|
||
&i.Content,
|
||
&i.Version,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.Session,
|
||
); 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 getQuestionTitle = `-- name: GetQuestionTitle :one
|
||
SELECT title, questiontype,page FROM question WHERE id = $1
|
||
`
|
||
|
||
type GetQuestionTitleRow struct {
|
||
Title string `db:"title" json:"title"`
|
||
Questiontype interface{} `db:"questiontype" json:"questiontype"`
|
||
Page sql.NullInt16 `db:"page" json:"page"`
|
||
}
|
||
|
||
func (q *Queries) GetQuestionTitle(ctx context.Context, id int64) (GetQuestionTitleRow, error) {
|
||
row := q.db.QueryRowContext(ctx, getQuestionTitle, id)
|
||
var i GetQuestionTitleRow
|
||
err := row.Scan(&i.Title, &i.Questiontype, &i.Page)
|
||
return i, err
|
||
}
|
||
|
||
const getQuestions = `-- name: GetQuestions :many
|
||
SELECT id, quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids, created_at, updated_at FROM question WHERE quiz_id = $1 AND deleted = FALSE ORDER BY page ASC
|
||
`
|
||
|
||
type GetQuestionsRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
Title string `db:"title" json:"title"`
|
||
Description sql.NullString `db:"description" json:"description"`
|
||
Questiontype interface{} `db:"questiontype" json:"questiontype"`
|
||
Required sql.NullBool `db:"required" json:"required"`
|
||
Deleted sql.NullBool `db:"deleted" json:"deleted"`
|
||
Page sql.NullInt16 `db:"page" json:"page"`
|
||
Content sql.NullString `db:"content" json:"content"`
|
||
Version sql.NullInt16 `db:"version" json:"version"`
|
||
ParentIds []int32 `db:"parent_ids" json:"parent_ids"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
}
|
||
|
||
func (q *Queries) GetQuestions(ctx context.Context, quizID int64) ([]GetQuestionsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getQuestions, quizID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetQuestionsRow
|
||
for rows.Next() {
|
||
var i GetQuestionsRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.Title,
|
||
&i.Description,
|
||
&i.Questiontype,
|
||
&i.Required,
|
||
&i.Deleted,
|
||
&i.Page,
|
||
&i.Content,
|
||
&i.Version,
|
||
pq.Array(&i.ParentIds),
|
||
&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 getQuestionsAI = `-- name: GetQuestionsAI :many
|
||
SELECT q.id, q.quiz_id, q.title, q.description, q.questiontype, q.required, q.deleted, q.page, q.content, q.version, q.parent_ids, q.created_at, q.updated_at, q.session FROM question q
|
||
WHERE q.quiz_id = $1 AND (q.session = $2 OR q.session = '') AND q.deleted = FALSE
|
||
ORDER BY (q.session != '') ASC, --без сессии первые потом с сессией
|
||
q.page, --по возрастанию страницы
|
||
q.created_at --по времени создания
|
||
LIMIT $3 OFFSET $4
|
||
`
|
||
|
||
type GetQuestionsAIParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
Session string `db:"session" json:"session"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
Offset int32 `db:"offset" json:"offset"`
|
||
}
|
||
|
||
func (q *Queries) GetQuestionsAI(ctx context.Context, arg GetQuestionsAIParams) ([]Question, error) {
|
||
rows, err := q.db.QueryContext(ctx, getQuestionsAI,
|
||
arg.QuizID,
|
||
arg.Session,
|
||
arg.Limit,
|
||
arg.Offset,
|
||
)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Question
|
||
for rows.Next() {
|
||
var i Question
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.QuizID,
|
||
&i.Title,
|
||
&i.Description,
|
||
&i.Questiontype,
|
||
&i.Required,
|
||
&i.Deleted,
|
||
&i.Page,
|
||
&i.Content,
|
||
&i.Version,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.Session,
|
||
); 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 getQuestionsAICount = `-- name: GetQuestionsAICount :one
|
||
SELECT COUNT(*) AS count FROM question WHERE quiz_id = $1 AND (session = $2 OR session = '') AND deleted = FALSE
|
||
`
|
||
|
||
type GetQuestionsAICountParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
Session string `db:"session" json:"session"`
|
||
}
|
||
|
||
func (q *Queries) GetQuestionsAICount(ctx context.Context, arg GetQuestionsAICountParams) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, getQuestionsAICount, arg.QuizID, arg.Session)
|
||
var count int64
|
||
err := row.Scan(&count)
|
||
return count, err
|
||
}
|
||
|
||
const getQuizAudience = `-- name: GetQuizAudience :many
|
||
SELECT id, quizid, sex, age, deleted, createdat FROM gigachatAudience WHERE QuizID = $1 AND Deleted = FALSE
|
||
`
|
||
|
||
func (q *Queries) GetQuizAudience(ctx context.Context, quizid int64) ([]Gigachataudience, error) {
|
||
rows, err := q.db.QueryContext(ctx, getQuizAudience, quizid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Gigachataudience
|
||
for rows.Next() {
|
||
var i Gigachataudience
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Quizid,
|
||
&i.Sex,
|
||
&i.Age,
|
||
&i.Deleted,
|
||
&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 getQuizById = `-- name: GetQuizById :one
|
||
SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count FROM quiz WHERE id=$1 AND accountId=$2
|
||
`
|
||
|
||
type GetQuizByIdParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) GetQuizById(ctx context.Context, arg GetQuizByIdParams) (Quiz, error) {
|
||
row := q.db.QueryRowContext(ctx, getQuizById, arg.ID, arg.Accountid)
|
||
var i Quiz
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Qid,
|
||
&i.Accountid,
|
||
&i.Deleted,
|
||
&i.Archived,
|
||
&i.Fingerprinting,
|
||
&i.Repeatable,
|
||
&i.NotePrevented,
|
||
&i.MailNotifications,
|
||
&i.UniqueAnswers,
|
||
&i.Super,
|
||
&i.GroupID,
|
||
&i.Name,
|
||
&i.Description,
|
||
&i.Config,
|
||
&i.Status,
|
||
&i.LimitAnswers,
|
||
&i.DueTo,
|
||
&i.TimeOfPassing,
|
||
&i.Pausable,
|
||
&i.Version,
|
||
&i.VersionComment,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.QuestionsCount,
|
||
&i.AnswersCount,
|
||
&i.AverageTimePassing,
|
||
&i.SessionsCount,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getQuizByQid = `-- name: GetQuizByQid :one
|
||
SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count FROM quiz
|
||
WHERE
|
||
deleted = false AND
|
||
archived = false AND
|
||
(status = 'start' OR status = 'ai') AND
|
||
qid = $1
|
||
`
|
||
|
||
func (q *Queries) GetQuizByQid(ctx context.Context, qid uuid.NullUUID) (Quiz, error) {
|
||
row := q.db.QueryRowContext(ctx, getQuizByQid, qid)
|
||
var i Quiz
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Qid,
|
||
&i.Accountid,
|
||
&i.Deleted,
|
||
&i.Archived,
|
||
&i.Fingerprinting,
|
||
&i.Repeatable,
|
||
&i.NotePrevented,
|
||
&i.MailNotifications,
|
||
&i.UniqueAnswers,
|
||
&i.Super,
|
||
&i.GroupID,
|
||
&i.Name,
|
||
&i.Description,
|
||
&i.Config,
|
||
&i.Status,
|
||
&i.LimitAnswers,
|
||
&i.DueTo,
|
||
&i.TimeOfPassing,
|
||
&i.Pausable,
|
||
&i.Version,
|
||
&i.VersionComment,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.QuestionsCount,
|
||
&i.AnswersCount,
|
||
&i.AverageTimePassing,
|
||
&i.SessionsCount,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getQuizConfig = `-- name: GetQuizConfig :one
|
||
SELECT config, accountid FROM quiz WHERE id = $1 AND deleted = false
|
||
`
|
||
|
||
type GetQuizConfigRow struct {
|
||
Config sql.NullString `db:"config" json:"config"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) GetQuizConfig(ctx context.Context, id int64) (GetQuizConfigRow, error) {
|
||
row := q.db.QueryRowContext(ctx, getQuizConfig, id)
|
||
var i GetQuizConfigRow
|
||
err := row.Scan(&i.Config, &i.Accountid)
|
||
return i, err
|
||
}
|
||
|
||
const getQuizHistory = `-- name: GetQuizHistory :many
|
||
SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count FROM quiz WHERE quiz.id = $1 AND quiz.accountId = $4 OR quiz.id = ANY(
|
||
SELECT unnest(parent_ids) FROM quiz WHERE id = $1
|
||
) ORDER BY quiz.id DESC LIMIT $2 OFFSET $3
|
||
`
|
||
|
||
type GetQuizHistoryParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
Offset int32 `db:"offset" json:"offset"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) GetQuizHistory(ctx context.Context, arg GetQuizHistoryParams) ([]Quiz, error) {
|
||
rows, err := q.db.QueryContext(ctx, getQuizHistory,
|
||
arg.ID,
|
||
arg.Limit,
|
||
arg.Offset,
|
||
arg.Accountid,
|
||
)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Quiz
|
||
for rows.Next() {
|
||
var i Quiz
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Qid,
|
||
&i.Accountid,
|
||
&i.Deleted,
|
||
&i.Archived,
|
||
&i.Fingerprinting,
|
||
&i.Repeatable,
|
||
&i.NotePrevented,
|
||
&i.MailNotifications,
|
||
&i.UniqueAnswers,
|
||
&i.Super,
|
||
&i.GroupID,
|
||
&i.Name,
|
||
&i.Description,
|
||
&i.Config,
|
||
&i.Status,
|
||
&i.LimitAnswers,
|
||
&i.DueTo,
|
||
&i.TimeOfPassing,
|
||
&i.Pausable,
|
||
&i.Version,
|
||
&i.VersionComment,
|
||
pq.Array(&i.ParentIds),
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.QuestionsCount,
|
||
&i.AnswersCount,
|
||
&i.AverageTimePassing,
|
||
&i.SessionsCount,
|
||
); 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 getQuizRule = `-- name: GetQuizRule :one
|
||
SELECT id, accountid, quizid, performerid, pipelineid, stepid, fieldsrule, deleted, createdat, tagstoadd FROM rules WHERE QuizID = $1 AND AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $2 AND accountsAmo.Deleted = false) AND Deleted = false
|
||
`
|
||
|
||
type GetQuizRuleParams struct {
|
||
Quizid int32 `db:"quizid" json:"quizid"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) GetQuizRule(ctx context.Context, arg GetQuizRuleParams) (Rule, error) {
|
||
row := q.db.QueryRowContext(ctx, getQuizRule, arg.Quizid, arg.Accountid)
|
||
var i Rule
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Accountid,
|
||
&i.Quizid,
|
||
&i.Performerid,
|
||
&i.Pipelineid,
|
||
&i.Stepid,
|
||
&i.Fieldsrule,
|
||
&i.Deleted,
|
||
&i.Createdat,
|
||
&i.Tagstoadd,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getResultAnswers = `-- name: GetResultAnswers :many
|
||
SELECT DISTINCT on (question_id) id, content, quiz_id, question_id, fingerprint, session,created_at, result, new,deleted, device_type,device,os,browser,ip FROM answer WHERE session = (
|
||
SELECT session FROM answer WHERE answer.id = $1) ORDER BY question_id, created_at DESC
|
||
`
|
||
|
||
type GetResultAnswersRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Content sql.NullString `db:"content" json:"content"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
QuestionID int64 `db:"question_id" json:"question_id"`
|
||
Fingerprint sql.NullString `db:"fingerprint" json:"fingerprint"`
|
||
Session sql.NullString `db:"session" json:"session"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
Result sql.NullBool `db:"result" json:"result"`
|
||
New sql.NullBool `db:"new" json:"new"`
|
||
Deleted sql.NullBool `db:"deleted" json:"deleted"`
|
||
DeviceType string `db:"device_type" json:"device_type"`
|
||
Device string `db:"device" json:"device"`
|
||
Os string `db:"os" json:"os"`
|
||
Browser string `db:"browser" json:"browser"`
|
||
Ip string `db:"ip" json:"ip"`
|
||
}
|
||
|
||
func (q *Queries) GetResultAnswers(ctx context.Context, id int64) ([]GetResultAnswersRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getResultAnswers, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetResultAnswersRow
|
||
for rows.Next() {
|
||
var i GetResultAnswersRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Content,
|
||
&i.QuizID,
|
||
&i.QuestionID,
|
||
&i.Fingerprint,
|
||
&i.Session,
|
||
&i.CreatedAt,
|
||
&i.Result,
|
||
&i.New,
|
||
&i.Deleted,
|
||
&i.DeviceType,
|
||
&i.Device,
|
||
&i.Os,
|
||
&i.Browser,
|
||
&i.Ip,
|
||
); 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 getStepsCount = `-- name: GetStepsCount :one
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT COUNT(*) FROM steps s JOIN user_data u ON s.AccountID = u.AmoID WHERE s.Deleted = false AND s.PipelineID = $2
|
||
`
|
||
|
||
type GetStepsCountParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
}
|
||
|
||
func (q *Queries) GetStepsCount(ctx context.Context, arg GetStepsCountParams) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, getStepsCount, arg.Accountid, arg.Pipelineid)
|
||
var count int64
|
||
err := row.Scan(&count)
|
||
return count, err
|
||
}
|
||
|
||
const getStepsWithPagination = `-- name: GetStepsWithPagination :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT s.id, s.amoid, s.pipelineid, s.accountid, s.name, s.color, s.deleted, s.createdat
|
||
FROM steps s JOIN user_data u ON s.AccountID = u.AmoID
|
||
WHERE s.Deleted = false AND s.PipelineID = $4
|
||
ORDER BY s.ID OFFSET ($2 - 1) * $3 LIMIT $3
|
||
`
|
||
|
||
type GetStepsWithPaginationParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 interface{} `db:"column_2" json:"column_2"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
}
|
||
|
||
func (q *Queries) GetStepsWithPagination(ctx context.Context, arg GetStepsWithPaginationParams) ([]Step, error) {
|
||
rows, err := q.db.QueryContext(ctx, getStepsWithPagination,
|
||
arg.Accountid,
|
||
arg.Column2,
|
||
arg.Limit,
|
||
arg.Pipelineid,
|
||
)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Step
|
||
for rows.Next() {
|
||
var i Step
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Pipelineid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Color,
|
||
&i.Deleted,
|
||
&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 getTagsCount = `-- name: GetTagsCount :one
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT COUNT(*) FROM tags t JOIN user_data u ON t.AccountID = u.AmoID WHERE t.Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetTagsCount(ctx context.Context, accountid string) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, getTagsCount, accountid)
|
||
var count int64
|
||
err := row.Scan(&count)
|
||
return count, err
|
||
}
|
||
|
||
const getTagsWithPagination = `-- name: GetTagsWithPagination :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT t.id, t.amoid, t.accountid, t.entity, t.name, t.color, t.deleted, t.createdat
|
||
FROM tags t JOIN user_data u ON t.AccountID = u.AmoID
|
||
WHERE t.Deleted = false
|
||
ORDER BY t.ID OFFSET ($2 - 1) * $3 LIMIT $3
|
||
`
|
||
|
||
type GetTagsWithPaginationParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 interface{} `db:"column_2" json:"column_2"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
}
|
||
|
||
func (q *Queries) GetTagsWithPagination(ctx context.Context, arg GetTagsWithPaginationParams) ([]Tag, error) {
|
||
rows, err := q.db.QueryContext(ctx, getTagsWithPagination, arg.Accountid, arg.Column2, arg.Limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Tag
|
||
for rows.Next() {
|
||
var i Tag
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Accountid,
|
||
&i.Entity,
|
||
&i.Name,
|
||
&i.Color,
|
||
&i.Deleted,
|
||
&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 getTokenById = `-- name: GetTokenById :one
|
||
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM tokens WHERE accountID = $1
|
||
`
|
||
|
||
func (q *Queries) GetTokenById(ctx context.Context, accountid string) (Token, error) {
|
||
row := q.db.QueryRowContext(ctx, getTokenById, accountid)
|
||
var i Token
|
||
err := row.Scan(
|
||
&i.Accountid,
|
||
&i.Refreshtoken,
|
||
&i.Accesstoken,
|
||
&i.Authcode,
|
||
&i.Expiration,
|
||
&i.Createdat,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const getUserFieldsByID = `-- name: GetUserFieldsByID :many
|
||
SELECT ID,AmoID,Code,AccountID,Name,Entity,Type
|
||
FROM fields
|
||
WHERE AccountID = $1 AND Deleted = false
|
||
`
|
||
|
||
type GetUserFieldsByIDRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Code string `db:"code" json:"code"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Entity interface{} `db:"entity" json:"entity"`
|
||
Type interface{} `db:"type" json:"type"`
|
||
}
|
||
|
||
func (q *Queries) GetUserFieldsByID(ctx context.Context, accountid int32) ([]GetUserFieldsByIDRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getUserFieldsByID, accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetUserFieldsByIDRow
|
||
for rows.Next() {
|
||
var i GetUserFieldsByIDRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Code,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Entity,
|
||
&i.Type,
|
||
); 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 getUserPipelinesByID = `-- name: GetUserPipelinesByID :many
|
||
SELECT ID,AmoID,AccountID,Name,IsArchive
|
||
FROM pipelines
|
||
WHERE AccountID = $1 AND Deleted = false
|
||
`
|
||
|
||
type GetUserPipelinesByIDRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Isarchive bool `db:"isarchive" json:"isarchive"`
|
||
}
|
||
|
||
func (q *Queries) GetUserPipelinesByID(ctx context.Context, accountid int32) ([]GetUserPipelinesByIDRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getUserPipelinesByID, accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetUserPipelinesByIDRow
|
||
for rows.Next() {
|
||
var i GetUserPipelinesByIDRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Isarchive,
|
||
); 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 getUserStepsByID = `-- name: GetUserStepsByID :many
|
||
SELECT ID,AmoID,PipelineID,AccountID,Name,Color
|
||
FROM steps
|
||
WHERE AccountID = $1 AND Deleted = false
|
||
`
|
||
|
||
type GetUserStepsByIDRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Color string `db:"color" json:"color"`
|
||
}
|
||
|
||
func (q *Queries) GetUserStepsByID(ctx context.Context, accountid int32) ([]GetUserStepsByIDRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getUserStepsByID, accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetUserStepsByIDRow
|
||
for rows.Next() {
|
||
var i GetUserStepsByIDRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Pipelineid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Color,
|
||
); 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 getUserTagsByID = `-- name: GetUserTagsByID :many
|
||
SELECT ID,AmoID,AccountID,Name,Entity,Color
|
||
FROM tags
|
||
WHERE AccountID = $1 AND Deleted = false
|
||
`
|
||
|
||
type GetUserTagsByIDRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Entity interface{} `db:"entity" json:"entity"`
|
||
Color string `db:"color" json:"color"`
|
||
}
|
||
|
||
func (q *Queries) GetUserTagsByID(ctx context.Context, accountid int32) ([]GetUserTagsByIDRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, getUserTagsByID, accountid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GetUserTagsByIDRow
|
||
for rows.Next() {
|
||
var i GetUserTagsByIDRow
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Accountid,
|
||
&i.Name,
|
||
&i.Entity,
|
||
&i.Color,
|
||
); 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 getUserUsersByID = `-- name: GetUserUsersByID :many
|
||
SELECT id, amoid, amouserid, name, email, role, "Group", deleted, createdat FROM usersAmo WHERE amoid = $1 AND Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetUserUsersByID(ctx context.Context, amoid int32) ([]Usersamo, error) {
|
||
rows, err := q.db.QueryContext(ctx, getUserUsersByID, amoid)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Usersamo
|
||
for rows.Next() {
|
||
var i Usersamo
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Amouserid,
|
||
&i.Name,
|
||
&i.Email,
|
||
&i.Role,
|
||
&i.Group,
|
||
&i.Deleted,
|
||
&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 getUsersCount = `-- name: GetUsersCount :one
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT COUNT(*) FROM usersAmo u JOIN user_data a ON u.AmoID = a.AmoID WHERE u.Deleted = false
|
||
`
|
||
|
||
func (q *Queries) GetUsersCount(ctx context.Context, accountid string) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, getUsersCount, accountid)
|
||
var count int64
|
||
err := row.Scan(&count)
|
||
return count, err
|
||
}
|
||
|
||
const getUsersWithPagination = `-- name: GetUsersWithPagination :many
|
||
WITH user_data AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
|
||
)
|
||
SELECT u.id, u.amoid, u.amouserid, u.name, u.email, u.role, u."Group", u.deleted, u.createdat
|
||
FROM usersAmo u
|
||
JOIN user_data a ON u.AmoID = a.AmoID
|
||
WHERE u.Deleted = false
|
||
ORDER BY u.ID OFFSET ($2 - 1) * $3 LIMIT $3
|
||
`
|
||
|
||
type GetUsersWithPaginationParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Column2 interface{} `db:"column_2" json:"column_2"`
|
||
Limit int32 `db:"limit" json:"limit"`
|
||
}
|
||
|
||
func (q *Queries) GetUsersWithPagination(ctx context.Context, arg GetUsersWithPaginationParams) ([]Usersamo, error) {
|
||
rows, err := q.db.QueryContext(ctx, getUsersWithPagination, arg.Accountid, arg.Column2, arg.Limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []Usersamo
|
||
for rows.Next() {
|
||
var i Usersamo
|
||
if err := rows.Scan(
|
||
&i.ID,
|
||
&i.Amoid,
|
||
&i.Amouserid,
|
||
&i.Name,
|
||
&i.Email,
|
||
&i.Role,
|
||
&i.Group,
|
||
&i.Deleted,
|
||
&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 gettingAmoUsersTrueResults = `-- name: GettingAmoUsersTrueResults :many
|
||
SELECT a.quiz_id,a.id,a.result,a.question_id,a.content,a.session,
|
||
COALESCE((SELECT a2.utm
|
||
FROM answer a2
|
||
WHERE a2.start = true AND a2.session = a.session
|
||
LIMIT 1), '{}'::jsonb) AS utm
|
||
,t.accesstoken,r.accountid,r.fieldsrule,r.tagstoadd,r.performerid,r.stepid,r.pipelineid,(SELECT u.name FROM usersAmo u WHERE u.AmoUserID = r.performerid AND u.amoid = r.accountid AND u.deleted = false) AS performer_name,u.subdomain,u.accountid,u.driveurl
|
||
FROM answer a
|
||
INNER JOIN quiz q ON a.quiz_id = q.id
|
||
LEFT JOIN amoCRMStatuses s ON a.id = s.AnswerID
|
||
INNER JOIN rules r ON q.id = r.QuizID
|
||
INNER JOIN tokens t ON q.accountid = t.AccountID
|
||
INNER JOIN accountsAmo u ON q.accountid = u.accountid AND u.amoid = r.accountid
|
||
WHERE a.result = true
|
||
AND s.id IS NULL
|
||
AND a.deleted = false
|
||
AND r.deleted = false
|
||
AND q.deleted = false
|
||
AND u.deleted = false
|
||
`
|
||
|
||
type GettingAmoUsersTrueResultsRow struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
ID int64 `db:"id" json:"id"`
|
||
Result sql.NullBool `db:"result" json:"result"`
|
||
QuestionID int64 `db:"question_id" json:"question_id"`
|
||
Content sql.NullString `db:"content" json:"content"`
|
||
Session sql.NullString `db:"session" json:"session"`
|
||
Utm interface{} `db:"utm" json:"utm"`
|
||
Accesstoken string `db:"accesstoken" json:"accesstoken"`
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Fieldsrule json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
|
||
Tagstoadd json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
|
||
Performerid int32 `db:"performerid" json:"performerid"`
|
||
Stepid int32 `db:"stepid" json:"stepid"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
PerformerName string `db:"performer_name" json:"performer_name"`
|
||
Subdomain string `db:"subdomain" json:"subdomain"`
|
||
Accountid_2 string `db:"accountid_2" json:"accountid_2"`
|
||
Driveurl string `db:"driveurl" json:"driveurl"`
|
||
}
|
||
|
||
func (q *Queries) GettingAmoUsersTrueResults(ctx context.Context) ([]GettingAmoUsersTrueResultsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, gettingAmoUsersTrueResults)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []GettingAmoUsersTrueResultsRow
|
||
for rows.Next() {
|
||
var i GettingAmoUsersTrueResultsRow
|
||
if err := rows.Scan(
|
||
&i.QuizID,
|
||
&i.ID,
|
||
&i.Result,
|
||
&i.QuestionID,
|
||
&i.Content,
|
||
&i.Session,
|
||
&i.Utm,
|
||
&i.Accesstoken,
|
||
&i.Accountid,
|
||
&i.Fieldsrule,
|
||
&i.Tagstoadd,
|
||
&i.Performerid,
|
||
&i.Stepid,
|
||
&i.Pipelineid,
|
||
&i.PerformerName,
|
||
&i.Subdomain,
|
||
&i.Accountid_2,
|
||
&i.Driveurl,
|
||
); 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 insertAnswers = `-- name: InsertAnswers :one
|
||
INSERT INTO answer(
|
||
content,
|
||
quiz_id,
|
||
question_id,
|
||
fingerprint,
|
||
session,
|
||
result,
|
||
email,
|
||
device_type,
|
||
device,
|
||
os,
|
||
browser,
|
||
ip,
|
||
start,
|
||
utm
|
||
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)
|
||
RETURNING id, content, quiz_id, question_id, fingerprint, session, created_at, result, new, deleted, email, device_type, device, os, browser, ip, start, utm
|
||
`
|
||
|
||
type InsertAnswersParams struct {
|
||
Content sql.NullString `db:"content" json:"content"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
QuestionID int64 `db:"question_id" json:"question_id"`
|
||
Fingerprint sql.NullString `db:"fingerprint" json:"fingerprint"`
|
||
Session sql.NullString `db:"session" json:"session"`
|
||
Result sql.NullBool `db:"result" json:"result"`
|
||
Email string `db:"email" json:"email"`
|
||
DeviceType string `db:"device_type" json:"device_type"`
|
||
Device string `db:"device" json:"device"`
|
||
Os string `db:"os" json:"os"`
|
||
Browser string `db:"browser" json:"browser"`
|
||
Ip string `db:"ip" json:"ip"`
|
||
Start bool `db:"start" json:"start"`
|
||
Utm json.RawMessage `db:"utm" json:"utm"`
|
||
}
|
||
|
||
func (q *Queries) InsertAnswers(ctx context.Context, arg InsertAnswersParams) (Answer, error) {
|
||
row := q.db.QueryRowContext(ctx, insertAnswers,
|
||
arg.Content,
|
||
arg.QuizID,
|
||
arg.QuestionID,
|
||
arg.Fingerprint,
|
||
arg.Session,
|
||
arg.Result,
|
||
arg.Email,
|
||
arg.DeviceType,
|
||
arg.Device,
|
||
arg.Os,
|
||
arg.Browser,
|
||
arg.Ip,
|
||
arg.Start,
|
||
arg.Utm,
|
||
)
|
||
var i Answer
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.Content,
|
||
&i.QuizID,
|
||
&i.QuestionID,
|
||
&i.Fingerprint,
|
||
&i.Session,
|
||
&i.CreatedAt,
|
||
&i.Result,
|
||
&i.New,
|
||
&i.Deleted,
|
||
&i.Email,
|
||
&i.DeviceType,
|
||
&i.Device,
|
||
&i.Os,
|
||
&i.Browser,
|
||
&i.Ip,
|
||
&i.Start,
|
||
&i.Utm,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const insertContactAmo = `-- name: InsertContactAmo :one
|
||
INSERT INTO amoContact (AccountID, AmoID, Field) VALUES ($1, $2, $3) RETURNING AmoID
|
||
`
|
||
|
||
type InsertContactAmoParams struct {
|
||
Accountid int32 `db:"accountid" json:"accountid"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Field string `db:"field" json:"field"`
|
||
}
|
||
|
||
func (q *Queries) InsertContactAmo(ctx context.Context, arg InsertContactAmoParams) (int32, error) {
|
||
row := q.db.QueryRowContext(ctx, insertContactAmo, arg.Accountid, arg.Amoid, arg.Field)
|
||
var amoid int32
|
||
err := row.Scan(&amoid)
|
||
return amoid, err
|
||
}
|
||
|
||
const insertPrivilege = `-- name: InsertPrivilege :exec
|
||
INSERT INTO privileges (privilegeID, account_id, privilege_name, amount, created_at) VALUES ($1, $2, $3, $4, $5)
|
||
`
|
||
|
||
type InsertPrivilegeParams struct {
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
AccountID uuid.NullUUID `db:"account_id" json:"account_id"`
|
||
PrivilegeName sql.NullString `db:"privilege_name" json:"privilege_name"`
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
}
|
||
|
||
func (q *Queries) InsertPrivilege(ctx context.Context, arg InsertPrivilegeParams) error {
|
||
_, err := q.db.ExecContext(ctx, insertPrivilege,
|
||
arg.Privilegeid,
|
||
arg.AccountID,
|
||
arg.PrivilegeName,
|
||
arg.Amount,
|
||
arg.CreatedAt,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const insertQuestion = `-- name: InsertQuestion :one
|
||
INSERT INTO question (
|
||
quiz_id,
|
||
title,
|
||
description,
|
||
questiontype,
|
||
required,
|
||
page,
|
||
content,
|
||
parent_ids,
|
||
updated_at,
|
||
session
|
||
)
|
||
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
|
||
RETURNING id, created_at, updated_at
|
||
`
|
||
|
||
type InsertQuestionParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
Title string `db:"title" json:"title"`
|
||
Description sql.NullString `db:"description" json:"description"`
|
||
Questiontype interface{} `db:"questiontype" json:"questiontype"`
|
||
Required sql.NullBool `db:"required" json:"required"`
|
||
Page sql.NullInt16 `db:"page" json:"page"`
|
||
Content sql.NullString `db:"content" json:"content"`
|
||
ParentIds []int32 `db:"parent_ids" json:"parent_ids"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
Session string `db:"session" json:"session"`
|
||
}
|
||
|
||
type InsertQuestionRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
}
|
||
|
||
func (q *Queries) InsertQuestion(ctx context.Context, arg InsertQuestionParams) (InsertQuestionRow, error) {
|
||
row := q.db.QueryRowContext(ctx, insertQuestion,
|
||
arg.QuizID,
|
||
arg.Title,
|
||
arg.Description,
|
||
arg.Questiontype,
|
||
arg.Required,
|
||
arg.Page,
|
||
arg.Content,
|
||
pq.Array(arg.ParentIds),
|
||
arg.UpdatedAt,
|
||
arg.Session,
|
||
)
|
||
var i InsertQuestionRow
|
||
err := row.Scan(&i.ID, &i.CreatedAt, &i.UpdatedAt)
|
||
return i, err
|
||
}
|
||
|
||
const insertQuiz = `-- name: InsertQuiz :one
|
||
INSERT INTO quiz (accountid,
|
||
fingerprinting,
|
||
repeatable,
|
||
note_prevented,
|
||
mail_notifications,
|
||
unique_answers,
|
||
super,
|
||
group_id,
|
||
name,
|
||
description,
|
||
config,
|
||
status,
|
||
limit_answers,
|
||
due_to,
|
||
time_of_passing,
|
||
pausable,
|
||
parent_ids,
|
||
questions_count,
|
||
qid
|
||
)
|
||
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19)
|
||
RETURNING id, created_at, updated_at, qid
|
||
`
|
||
|
||
type InsertQuizParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Fingerprinting sql.NullBool `db:"fingerprinting" json:"fingerprinting"`
|
||
Repeatable sql.NullBool `db:"repeatable" json:"repeatable"`
|
||
NotePrevented sql.NullBool `db:"note_prevented" json:"note_prevented"`
|
||
MailNotifications sql.NullBool `db:"mail_notifications" json:"mail_notifications"`
|
||
UniqueAnswers sql.NullBool `db:"unique_answers" json:"unique_answers"`
|
||
Super sql.NullBool `db:"super" json:"super"`
|
||
GroupID sql.NullInt64 `db:"group_id" json:"group_id"`
|
||
Name sql.NullString `db:"name" json:"name"`
|
||
Description sql.NullString `db:"description" json:"description"`
|
||
Config sql.NullString `db:"config" json:"config"`
|
||
Status interface{} `db:"status" json:"status"`
|
||
LimitAnswers sql.NullInt32 `db:"limit_answers" json:"limit_answers"`
|
||
DueTo sql.NullInt32 `db:"due_to" json:"due_to"`
|
||
TimeOfPassing sql.NullInt32 `db:"time_of_passing" json:"time_of_passing"`
|
||
Pausable sql.NullBool `db:"pausable" json:"pausable"`
|
||
ParentIds []int32 `db:"parent_ids" json:"parent_ids"`
|
||
QuestionsCount sql.NullInt32 `db:"questions_count" json:"questions_count"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
}
|
||
|
||
type InsertQuizRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
}
|
||
|
||
func (q *Queries) InsertQuiz(ctx context.Context, arg InsertQuizParams) (InsertQuizRow, error) {
|
||
row := q.db.QueryRowContext(ctx, insertQuiz,
|
||
arg.Accountid,
|
||
arg.Fingerprinting,
|
||
arg.Repeatable,
|
||
arg.NotePrevented,
|
||
arg.MailNotifications,
|
||
arg.UniqueAnswers,
|
||
arg.Super,
|
||
arg.GroupID,
|
||
arg.Name,
|
||
arg.Description,
|
||
arg.Config,
|
||
arg.Status,
|
||
arg.LimitAnswers,
|
||
arg.DueTo,
|
||
arg.TimeOfPassing,
|
||
arg.Pausable,
|
||
pq.Array(arg.ParentIds),
|
||
arg.QuestionsCount,
|
||
arg.Qid,
|
||
)
|
||
var i InsertQuizRow
|
||
err := row.Scan(
|
||
&i.ID,
|
||
&i.CreatedAt,
|
||
&i.UpdatedAt,
|
||
&i.Qid,
|
||
)
|
||
return i, err
|
||
}
|
||
|
||
const moveToHistory = `-- name: MoveToHistory :one
|
||
INSERT INTO question(
|
||
quiz_id, title, description, questiontype, required,
|
||
page, content, version, parent_ids, deleted
|
||
)
|
||
SELECT quiz_id, title, description, questiontype, required,
|
||
page, content, version, parent_ids, true as deleted
|
||
FROM question WHERE question.id=$1
|
||
RETURNING question.id, quiz_id, parent_ids
|
||
`
|
||
|
||
type MoveToHistoryRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
ParentIds []int32 `db:"parent_ids" json:"parent_ids"`
|
||
}
|
||
|
||
func (q *Queries) MoveToHistory(ctx context.Context, id int64) (MoveToHistoryRow, error) {
|
||
row := q.db.QueryRowContext(ctx, moveToHistory, id)
|
||
var i MoveToHistoryRow
|
||
err := row.Scan(&i.ID, &i.QuizID, pq.Array(&i.ParentIds))
|
||
return i, err
|
||
}
|
||
|
||
const moveToHistoryQuiz = `-- name: MoveToHistoryQuiz :one
|
||
INSERT INTO quiz(deleted,
|
||
accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
|
||
status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count,answers_count,average_time_passing, super, group_id
|
||
)
|
||
SELECT true as deleted, accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
|
||
status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count,answers_count,average_time_passing, super, group_id
|
||
FROM quiz WHERE quiz.id=$1 AND quiz.accountid=$2
|
||
RETURNING quiz.id, qid, parent_ids
|
||
`
|
||
|
||
type MoveToHistoryQuizParams struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
type MoveToHistoryQuizRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
ParentIds []int32 `db:"parent_ids" json:"parent_ids"`
|
||
}
|
||
|
||
func (q *Queries) MoveToHistoryQuiz(ctx context.Context, arg MoveToHistoryQuizParams) (MoveToHistoryQuizRow, error) {
|
||
row := q.db.QueryRowContext(ctx, moveToHistoryQuiz, arg.ID, arg.Accountid)
|
||
var i MoveToHistoryQuizRow
|
||
err := row.Scan(&i.ID, &i.Qid, pq.Array(&i.ParentIds))
|
||
return i, err
|
||
}
|
||
|
||
const questionsStatistics = `-- name: QuestionsStatistics :many
|
||
WITH QuizAnswers AS (
|
||
SELECT
|
||
session, start, result, question_id, created_at, content, quiz_id
|
||
FROM answer
|
||
WHERE answer.quiz_id = $1 AND created_at between TO_TIMESTAMP($2)::timestamp and TO_TIMESTAMP($3)::timestamp
|
||
), QuizQuestions AS (SELECT title, page, id from question where quiz_id = $1), Funnel AS (
|
||
SELECT
|
||
COUNT(DISTINCT a.session) FILTER (WHERE a.start = FALSE) AS count_start_false,
|
||
COUNT(DISTINCT a.session) FILTER (WHERE a.start = TRUE) AS count_start_true,
|
||
COUNT(DISTINCT CASE WHEN a.result = FALSE AND qid_true_result IS NOT NULL THEN a.session END) AS count_f_result_with_t_question,
|
||
COUNT(DISTINCT a.session) FILTER (WHERE a.result = TRUE) AS count_t_result
|
||
FROM
|
||
QuizAnswers a
|
||
LEFT JOIN (
|
||
SELECT DISTINCT a.session, q.id AS qid_true_result
|
||
FROM QuizAnswers a
|
||
JOIN question q ON a.question_id = q.id
|
||
WHERE a.result = TRUE
|
||
) AS q ON a.session = q.session
|
||
),
|
||
Results AS (
|
||
SELECT
|
||
COALESCE(q.title, '') AS question_title,
|
||
COUNT(*) AS total_answers,
|
||
CAST(COUNT(*) * 100.0 / NULLIF(SUM(COUNT(*)) FILTER (WHERE a.result = TRUE) OVER (PARTITION BY a.quiz_id), 0) AS FLOAT8) AS percentage
|
||
FROM
|
||
question q
|
||
LEFT JOIN QuizAnswers a ON q.id = a.question_id
|
||
WHERE
|
||
a.result = TRUE
|
||
GROUP BY
|
||
q.title, a.result, a.quiz_id
|
||
HAVING
|
||
COUNT(*) >= 1
|
||
),
|
||
LastContent AS (
|
||
SELECT
|
||
a.question_id,
|
||
a.content AS last_answer_content,
|
||
a.result,
|
||
a.start
|
||
FROM
|
||
QuizAnswers a
|
||
LEFT JOIN (
|
||
SELECT
|
||
session,
|
||
question_id,
|
||
MAX(created_at) AS last_created_at
|
||
FROM
|
||
QuizAnswers
|
||
WHERE
|
||
start != true
|
||
GROUP BY
|
||
question_id, session
|
||
) AS last_created_at_one_session ON a.session = last_created_at_one_session.session
|
||
AND a.question_id = last_created_at_one_session.question_id
|
||
AND a.created_at = last_created_at_one_session.last_created_at
|
||
),
|
||
Questions AS (
|
||
SELECT
|
||
q.title AS question_title,
|
||
MAX(q.page) AS question_page,
|
||
lc.last_answer_content AS answer_content,
|
||
CAST(
|
||
COUNT(CASE WHEN lc.result = FALSE THEN 1 END) * 100.0 / NULLIF(SUM(COUNT(CASE WHEN lc.result = FALSE THEN 1 END)) OVER (PARTITION BY q.id), 0) AS FLOAT8
|
||
) AS percentage
|
||
FROM
|
||
LastContent lc
|
||
JOIN QuizQuestions q ON q.id = lc.question_id
|
||
WHERE
|
||
lc.start != true
|
||
GROUP BY
|
||
q.id, q.title, lc.last_answer_content
|
||
HAVING
|
||
COUNT(*) >= 1
|
||
)
|
||
SELECT
|
||
Funnel.count_start_false,
|
||
Funnel.count_start_true,
|
||
Funnel.count_f_result_with_t_question,
|
||
Funnel.count_t_result,
|
||
COALESCE(Results.question_title, '') AS results_title,
|
||
COALESCE(Results.percentage, 0) AS results_percentage,
|
||
COALESCE(Questions.question_title, '') AS questions_title,
|
||
COALESCE(Questions.question_page, 0) AS questions_page,
|
||
COALESCE(Questions.answer_content, '') AS answer_content,
|
||
COALESCE(Questions.percentage, 0) AS questions_percentage
|
||
FROM
|
||
Funnel
|
||
LEFT JOIN Results ON true
|
||
LEFT JOIN Questions ON Questions.percentage >= 1
|
||
`
|
||
|
||
type QuestionsStatisticsParams struct {
|
||
QuizID int64 `db:"quiz_id" json:"quiz_id"`
|
||
ToTimestamp float64 `db:"to_timestamp" json:"to_timestamp"`
|
||
ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
|
||
}
|
||
|
||
type QuestionsStatisticsRow struct {
|
||
CountStartFalse int64 `db:"count_start_false" json:"count_start_false"`
|
||
CountStartTrue int64 `db:"count_start_true" json:"count_start_true"`
|
||
CountFResultWithTQuestion int64 `db:"count_f_result_with_t_question" json:"count_f_result_with_t_question"`
|
||
CountTResult int64 `db:"count_t_result" json:"count_t_result"`
|
||
ResultsTitle string `db:"results_title" json:"results_title"`
|
||
ResultsPercentage float64 `db:"results_percentage" json:"results_percentage"`
|
||
QuestionsTitle string `db:"questions_title" json:"questions_title"`
|
||
QuestionsPage interface{} `db:"questions_page" json:"questions_page"`
|
||
AnswerContent string `db:"answer_content" json:"answer_content"`
|
||
QuestionsPercentage float64 `db:"questions_percentage" json:"questions_percentage"`
|
||
}
|
||
|
||
func (q *Queries) QuestionsStatistics(ctx context.Context, arg QuestionsStatisticsParams) ([]QuestionsStatisticsRow, error) {
|
||
rows, err := q.db.QueryContext(ctx, questionsStatistics, arg.QuizID, arg.ToTimestamp, arg.ToTimestamp_2)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
var items []QuestionsStatisticsRow
|
||
for rows.Next() {
|
||
var i QuestionsStatisticsRow
|
||
if err := rows.Scan(
|
||
&i.CountStartFalse,
|
||
&i.CountStartTrue,
|
||
&i.CountFResultWithTQuestion,
|
||
&i.CountTResult,
|
||
&i.ResultsTitle,
|
||
&i.ResultsPercentage,
|
||
&i.QuestionsTitle,
|
||
&i.QuestionsPage,
|
||
&i.AnswerContent,
|
||
&i.QuestionsPercentage,
|
||
); 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 quizCopyQid = `-- name: QuizCopyQid :one
|
||
INSERT INTO quiz (
|
||
accountid, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, name, description, config,
|
||
status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, questions_count, answers_count, average_time_passing, super, group_id
|
||
)
|
||
SELECT
|
||
$2, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, name, description, config,
|
||
status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, questions_count, answers_count, average_time_passing, super, group_id
|
||
FROM
|
||
quiz as q
|
||
WHERE
|
||
q.qid = $1
|
||
RETURNING (select id from quiz where qid = $1),id, qid
|
||
`
|
||
|
||
type QuizCopyQidParams struct {
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
type QuizCopyQidRow struct {
|
||
ID int64 `db:"id" json:"id"`
|
||
ID_2 int64 `db:"id_2" json:"id_2"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
}
|
||
|
||
func (q *Queries) QuizCopyQid(ctx context.Context, arg QuizCopyQidParams) (QuizCopyQidRow, error) {
|
||
row := q.db.QueryRowContext(ctx, quizCopyQid, arg.Qid, arg.Accountid)
|
||
var i QuizCopyQidRow
|
||
err := row.Scan(&i.ID, &i.ID_2, &i.Qid)
|
||
return i, err
|
||
}
|
||
|
||
const setQuizSettings = `-- name: SetQuizSettings :one
|
||
INSERT INTO rules (AccountID, QuizID, PerformerID, PipelineID, StepID, FieldsRule,TagsToAdd)
|
||
SELECT u.AmoID AS AccountID,$1 AS QuizID,$2 AS PerformerID,$3 AS PipelineID,
|
||
$4 AS StepID,$5 AS FieldsRule,$6 AS TagsToAdd FROM accountsamo u WHERE u.AccountID = $7 AND u.Deleted = false
|
||
RETURNING id
|
||
`
|
||
|
||
type SetQuizSettingsParams struct {
|
||
Quizid int32 `db:"quizid" json:"quizid"`
|
||
Performerid int32 `db:"performerid" json:"performerid"`
|
||
Pipelineid int32 `db:"pipelineid" json:"pipelineid"`
|
||
Stepid int32 `db:"stepid" json:"stepid"`
|
||
Fieldsrule json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
|
||
Tagstoadd json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) SetQuizSettings(ctx context.Context, arg SetQuizSettingsParams) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, setQuizSettings,
|
||
arg.Quizid,
|
||
arg.Performerid,
|
||
arg.Pipelineid,
|
||
arg.Stepid,
|
||
arg.Fieldsrule,
|
||
arg.Tagstoadd,
|
||
arg.Accountid,
|
||
)
|
||
var id int64
|
||
err := row.Scan(&id)
|
||
return id, err
|
||
}
|
||
|
||
const settingDealAmoStatus = `-- name: SettingDealAmoStatus :exec
|
||
INSERT INTO amoCRMStatuses (AccountID, DealID, AnswerID, Status)
|
||
SELECT u.AmoID, $1, $2, $3
|
||
FROM tokens AS t
|
||
JOIN accountsAmo AS u ON t.AccountID = u.AccountID
|
||
WHERE t.AccessToken = $4 AND u.Deleted = false
|
||
`
|
||
|
||
type SettingDealAmoStatusParams struct {
|
||
Dealid int32 `db:"dealid" json:"dealid"`
|
||
Answerid int64 `db:"answerid" json:"answerid"`
|
||
Status string `db:"status" json:"status"`
|
||
Accesstoken string `db:"accesstoken" json:"accesstoken"`
|
||
}
|
||
|
||
func (q *Queries) SettingDealAmoStatus(ctx context.Context, arg SettingDealAmoStatusParams) error {
|
||
_, err := q.db.ExecContext(ctx, settingDealAmoStatus,
|
||
arg.Dealid,
|
||
arg.Answerid,
|
||
arg.Status,
|
||
arg.Accesstoken,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const softDeleteAccount = `-- name: SoftDeleteAccount :exec
|
||
WITH amoCompany AS (
|
||
SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND deleted = false
|
||
),usersDel AS (
|
||
UPDATE usersAmo SET Deleted = true WHERE AmoID = (SELECT AmoID FROM amoCompany)
|
||
),
|
||
companyDel AS ( UPDATE accountsAmo SET Deleted = true WHERE AmoID = (SELECT AmoID FROM amoCompany)
|
||
)
|
||
DELETE FROM tokens WHERE tokens.AccountID = $1
|
||
`
|
||
|
||
func (q *Queries) SoftDeleteAccount(ctx context.Context, accountid string) error {
|
||
_, err := q.db.ExecContext(ctx, softDeleteAccount, accountid)
|
||
return err
|
||
}
|
||
|
||
const softDeleteResultByID = `-- name: SoftDeleteResultByID :exec
|
||
UPDATE answer SET deleted = TRUE WHERE id = $1 AND deleted = FALSE
|
||
`
|
||
|
||
func (q *Queries) SoftDeleteResultByID(ctx context.Context, id int64) error {
|
||
_, err := q.db.ExecContext(ctx, softDeleteResultByID, id)
|
||
return err
|
||
}
|
||
|
||
const templateCopy = `-- name: TemplateCopy :one
|
||
WITH copied_quiz AS (
|
||
INSERT INTO quiz (accountid, name,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,super,group_id, description, config, status,limit_answers,due_to,time_of_passing,pausable,version,version_comment, parent_ids)
|
||
SELECT $1 AS accountid,name,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,super,group_id, description, config, 'stop' AS status,limit_answers,due_to,time_of_passing,pausable,version,version_comment, parent_ids
|
||
FROM quiz
|
||
WHERE qid = $2 and status = 'template'
|
||
RETURNING id
|
||
)
|
||
INSERT INTO question (quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids)
|
||
SELECT cq.id AS quiz_id, q.title, q.description, q.questiontype, q.required, q.deleted, q.page, q.content, q.version, q.parent_ids
|
||
FROM question q
|
||
JOIN quiz old ON q.quiz_id = old.id
|
||
JOIN copied_quiz cq ON old.qid = $2
|
||
RETURNING quiz_id
|
||
`
|
||
|
||
type TemplateCopyParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Qid uuid.NullUUID `db:"qid" json:"qid"`
|
||
}
|
||
|
||
func (q *Queries) TemplateCopy(ctx context.Context, arg TemplateCopyParams) (int64, error) {
|
||
row := q.db.QueryRowContext(ctx, templateCopy, arg.Accountid, arg.Qid)
|
||
var quiz_id int64
|
||
err := row.Scan(&quiz_id)
|
||
return quiz_id, err
|
||
}
|
||
|
||
const updateAmoAccount = `-- name: UpdateAmoAccount :exec
|
||
UPDATE accountsAmo SET Name = $2, Subdomain = $3, Country = $4, DriveURL = $5 WHERE AccountID = $1 AND Deleted = false
|
||
`
|
||
|
||
type UpdateAmoAccountParams struct {
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Name string `db:"name" json:"name"`
|
||
Subdomain string `db:"subdomain" json:"subdomain"`
|
||
Country string `db:"country" json:"country"`
|
||
Driveurl string `db:"driveurl" json:"driveurl"`
|
||
}
|
||
|
||
func (q *Queries) UpdateAmoAccount(ctx context.Context, arg UpdateAmoAccountParams) error {
|
||
_, err := q.db.ExecContext(ctx, updateAmoAccount,
|
||
arg.Accountid,
|
||
arg.Name,
|
||
arg.Subdomain,
|
||
arg.Country,
|
||
arg.Driveurl,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const updateAmoAccountUser = `-- name: UpdateAmoAccountUser :exec
|
||
UPDATE usersAmo SET Name = $3, Email = $4, Role = $5, "Group" = $6
|
||
WHERE AmoID = $1 AND AmoUserID = $2 AND deleted = false
|
||
`
|
||
|
||
type UpdateAmoAccountUserParams struct {
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
Amouserid int32 `db:"amouserid" json:"amouserid"`
|
||
Name string `db:"name" json:"name"`
|
||
Email string `db:"email" json:"email"`
|
||
Role int32 `db:"role" json:"role"`
|
||
Group int32 `db:"Group" json:"Group"`
|
||
}
|
||
|
||
func (q *Queries) UpdateAmoAccountUser(ctx context.Context, arg UpdateAmoAccountUserParams) error {
|
||
_, err := q.db.ExecContext(ctx, updateAmoAccountUser,
|
||
arg.Amoid,
|
||
arg.Amouserid,
|
||
arg.Name,
|
||
arg.Email,
|
||
arg.Role,
|
||
arg.Group,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const updateAmoContact = `-- name: UpdateAmoContact :exec
|
||
UPDATE amoContact SET Field = $1,AmoID=$3 WHERE ID = $2
|
||
`
|
||
|
||
type UpdateAmoContactParams struct {
|
||
Field string `db:"field" json:"field"`
|
||
ID int64 `db:"id" json:"id"`
|
||
Amoid int32 `db:"amoid" json:"amoid"`
|
||
}
|
||
|
||
func (q *Queries) UpdateAmoContact(ctx context.Context, arg UpdateAmoContactParams) error {
|
||
_, err := q.db.ExecContext(ctx, updateAmoContact, arg.Field, arg.ID, arg.Amoid)
|
||
return err
|
||
}
|
||
|
||
const updateFieldRules = `-- name: UpdateFieldRules :exec
|
||
UPDATE rules SET FieldsRule = $1
|
||
WHERE AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $2 AND accountsAmo.Deleted = false) AND QuizID = $3 AND Deleted = false
|
||
`
|
||
|
||
type UpdateFieldRulesParams struct {
|
||
Fieldsrule json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
Quizid int32 `db:"quizid" json:"quizid"`
|
||
}
|
||
|
||
func (q *Queries) UpdateFieldRules(ctx context.Context, arg UpdateFieldRulesParams) error {
|
||
_, err := q.db.ExecContext(ctx, updateFieldRules, arg.Fieldsrule, arg.Accountid, arg.Quizid)
|
||
return err
|
||
}
|
||
|
||
const updateFields = `-- name: UpdateFields :exec
|
||
UPDATE fields AS f
|
||
SET name = (update_data ->> 'Name')::varchar(512),
|
||
code = (update_data ->> 'Code')::varchar(255),
|
||
type = (update_data ->> 'Type')::fieldtype
|
||
FROM json_array_elements($1::json) AS update_data
|
||
WHERE f.amoID = (update_data ->> 'AmoID')::INT
|
||
AND f.accountID = (update_data ->> 'AccountID')::INT
|
||
AND f.Entity = (update_data ->> 'Entity')::entitytype
|
||
`
|
||
|
||
func (q *Queries) UpdateFields(ctx context.Context, dollar_1 json.RawMessage) error {
|
||
_, err := q.db.ExecContext(ctx, updateFields, dollar_1)
|
||
return err
|
||
}
|
||
|
||
const updatePipelines = `-- name: UpdatePipelines :exec
|
||
UPDATE pipelines AS p
|
||
SET name = (update_data ->> 'Name')::varchar(512),
|
||
isArchive = CASE WHEN (update_data ->> 'IsArchive') = 'true' THEN TRUE ELSE FALSE END
|
||
FROM json_array_elements($1::json) AS update_data
|
||
WHERE p.amoID = (update_data ->> 'AmoID')::INT
|
||
AND p.accountID = (update_data ->> 'AccountID')::INT
|
||
`
|
||
|
||
func (q *Queries) UpdatePipelines(ctx context.Context, dollar_1 json.RawMessage) error {
|
||
_, err := q.db.ExecContext(ctx, updatePipelines, dollar_1)
|
||
return err
|
||
}
|
||
|
||
const updatePrivilege = `-- name: UpdatePrivilege :exec
|
||
UPDATE privileges SET amount = $1, created_at = $2 WHERE account_id = $3 AND privilegeID = $4
|
||
`
|
||
|
||
type UpdatePrivilegeParams struct {
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
|
||
AccountID uuid.NullUUID `db:"account_id" json:"account_id"`
|
||
Privilegeid sql.NullString `db:"privilegeid" json:"privilegeid"`
|
||
}
|
||
|
||
func (q *Queries) UpdatePrivilege(ctx context.Context, arg UpdatePrivilegeParams) error {
|
||
_, err := q.db.ExecContext(ctx, updatePrivilege,
|
||
arg.Amount,
|
||
arg.CreatedAt,
|
||
arg.AccountID,
|
||
arg.Privilegeid,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const updatePrivilegeAmount = `-- name: UpdatePrivilegeAmount :exec
|
||
UPDATE privileges SET amount = $1 WHERE id = $2
|
||
`
|
||
|
||
type UpdatePrivilegeAmountParams struct {
|
||
Amount sql.NullInt32 `db:"amount" json:"amount"`
|
||
ID int32 `db:"id" json:"id"`
|
||
}
|
||
|
||
func (q *Queries) UpdatePrivilegeAmount(ctx context.Context, arg UpdatePrivilegeAmountParams) error {
|
||
_, err := q.db.ExecContext(ctx, updatePrivilegeAmount, arg.Amount, arg.ID)
|
||
return err
|
||
}
|
||
|
||
const updateSteps = `-- name: UpdateSteps :exec
|
||
UPDATE steps AS s
|
||
SET name = (update_data ->> 'Name')::varchar(512),
|
||
color = (update_data ->> 'Color')::varchar(50)
|
||
FROM json_array_elements($1::json) AS update_data
|
||
WHERE s.amoID = (update_data ->> 'AmoID')::INT
|
||
AND s.accountID = (update_data ->> 'AccountID')::INT
|
||
AND s.pipelineID = (update_data ->> 'PipelineID')::INT
|
||
`
|
||
|
||
func (q *Queries) UpdateSteps(ctx context.Context, dollar_1 json.RawMessage) error {
|
||
_, err := q.db.ExecContext(ctx, updateSteps, dollar_1)
|
||
return err
|
||
}
|
||
|
||
const updateTags = `-- name: UpdateTags :exec
|
||
UPDATE tags AS t
|
||
SET name = (update_data ->> 'Name')::varchar(512),
|
||
color = (update_data ->> 'Color')::varchar(50)
|
||
FROM json_array_elements($1::json) AS update_data
|
||
WHERE t.amoID = (update_data ->> 'AmoID')::INT
|
||
AND t.accountID = (update_data ->> 'AccountID')::INT
|
||
AND t.Entity = (update_data ->> 'Entity')::entitytype
|
||
`
|
||
|
||
func (q *Queries) UpdateTags(ctx context.Context, dollar_1 json.RawMessage) error {
|
||
_, err := q.db.ExecContext(ctx, updateTags, dollar_1)
|
||
return err
|
||
}
|
||
|
||
const updatingDealAmoStatus = `-- name: UpdatingDealAmoStatus :exec
|
||
UPDATE amoCRMStatuses SET Status = $1
|
||
WHERE DealID = $2 AND AccountID = (SELECT u.AmoID FROM tokens AS t JOIN accountsAmo AS u ON t.AccountID = u.AccountID WHERE t.AccessToken = $3 AND u.Deleted = false)
|
||
`
|
||
|
||
type UpdatingDealAmoStatusParams struct {
|
||
Status string `db:"status" json:"status"`
|
||
Dealid int32 `db:"dealid" json:"dealid"`
|
||
Accesstoken string `db:"accesstoken" json:"accesstoken"`
|
||
}
|
||
|
||
func (q *Queries) UpdatingDealAmoStatus(ctx context.Context, arg UpdatingDealAmoStatusParams) error {
|
||
_, err := q.db.ExecContext(ctx, updatingDealAmoStatus, arg.Status, arg.Dealid, arg.Accesstoken)
|
||
return err
|
||
}
|
||
|
||
const webhookDelete = `-- name: WebhookDelete :exec
|
||
WITH companyDel AS (
|
||
UPDATE accountsAmo SET Deleted = true WHERE accountsAmo.AmoID = $1 RETURNING AccountID
|
||
),
|
||
userDel AS (
|
||
UPDATE usersAmo SET Deleted = true WHERE AmoID = $1
|
||
)
|
||
DELETE FROM tokens WHERE AccountID IN (SELECT AccountID FROM companyDel)
|
||
`
|
||
|
||
func (q *Queries) WebhookDelete(ctx context.Context, amoid int32) error {
|
||
_, err := q.db.ExecContext(ctx, webhookDelete, amoid)
|
||
return err
|
||
}
|
||
|
||
const webhookUpdate = `-- name: WebhookUpdate :exec
|
||
UPDATE tokens SET AccessToken = $1,RefreshToken = $2,Expiration = to_timestamp(($3)::bigint) AT TIME ZONE 'UTC' + INTERVAL '3 hours',CreatedAt = to_timestamp(($4)::bigint) AT TIME ZONE 'UTC' + INTERVAL '3 hours'
|
||
WHERE accountID = $5
|
||
`
|
||
|
||
type WebhookUpdateParams struct {
|
||
Accesstoken string `db:"accesstoken" json:"accesstoken"`
|
||
Refreshtoken string `db:"refreshtoken" json:"refreshtoken"`
|
||
Column3 int64 `db:"column_3" json:"column_3"`
|
||
Column4 int64 `db:"column_4" json:"column_4"`
|
||
Accountid string `db:"accountid" json:"accountid"`
|
||
}
|
||
|
||
func (q *Queries) WebhookUpdate(ctx context.Context, arg WebhookUpdateParams) error {
|
||
_, err := q.db.ExecContext(ctx, webhookUpdate,
|
||
arg.Accesstoken,
|
||
arg.Refreshtoken,
|
||
arg.Column3,
|
||
arg.Column4,
|
||
arg.Accountid,
|
||
)
|
||
return err
|
||
}
|
||
|
||
const workerStatProcess = `-- name: WorkerStatProcess :exec
|
||
WITH answer_aggregates AS (
|
||
SELECT
|
||
quiz_id,
|
||
COUNT(DISTINCT session) AS unique_true_answers_count
|
||
FROM
|
||
answer
|
||
WHERE
|
||
result = TRUE
|
||
GROUP BY
|
||
quiz_id
|
||
),
|
||
question_aggregates AS (
|
||
SELECT
|
||
q.id AS quiz_id,
|
||
COUNT(qs.id) AS total_questions
|
||
FROM
|
||
quiz q
|
||
INNER JOIN
|
||
question qs ON q.id = qs.quiz_id
|
||
WHERE
|
||
q.deleted = false
|
||
AND q.archived = false
|
||
AND qs.deleted = false
|
||
GROUP BY
|
||
q.id
|
||
),
|
||
session_times_aggregates AS (
|
||
SELECT
|
||
quiz_id, COUNT(session) as sess,
|
||
AVG(extract(epoch FROM session_time)) AS average_session_time
|
||
FROM (
|
||
SELECT
|
||
quiz_id,
|
||
session,
|
||
(MAX(created_at) - MIN(created_at)) AS session_time
|
||
FROM
|
||
answer
|
||
GROUP BY
|
||
quiz_id,
|
||
session
|
||
) AS all_sessions
|
||
GROUP BY
|
||
quiz_id
|
||
)
|
||
UPDATE quiz q
|
||
SET
|
||
questions_count = COALESCE(qa.total_questions, 0),
|
||
answers_count = COALESCE(aa.unique_true_answers_count, 0),
|
||
average_time_passing = COALESCE(sta.average_session_time, 0),
|
||
sessions_count = COALESCE(sta.sess,0)
|
||
FROM
|
||
(SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count FROM quiz WHERE deleted = FALSE AND archived = FALSE) q_sub
|
||
LEFT JOIN answer_aggregates aa ON q_sub.id = aa.quiz_id
|
||
LEFT JOIN question_aggregates qa ON q_sub.id = qa.quiz_id
|
||
LEFT JOIN session_times_aggregates sta ON q_sub.id = sta.quiz_id
|
||
WHERE
|
||
q.id = q_sub.id
|
||
`
|
||
|
||
func (q *Queries) WorkerStatProcess(ctx context.Context) error {
|
||
_, err := q.db.ExecContext(ctx, workerStatProcess)
|
||
return err
|
||
}
|
||
|
||
const workerTimeoutProcess = `-- name: WorkerTimeoutProcess :exec
|
||
UPDATE quiz SET status = 'timeout' WHERE deleted = false AND due_to <> 0 AND due_to < EXTRACT(epoch FROM CURRENT_TIMESTAMP)
|
||
`
|
||
|
||
func (q *Queries) WorkerTimeoutProcess(ctx context.Context) error {
|
||
_, err := q.db.ExecContext(ctx, workerTimeoutProcess)
|
||
return err
|
||
}
|