// Code generated by sqlc. DO NOT EDIT. // versions: // sqlc v1.27.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 WHERE AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $6 AND accountsAmo.Deleted = false) AND QuizID = $7 AND Deleted = false 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 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 ` 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, ) return i, 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 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, COUNT(*) OVER() as total_count 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"` } type GetFieldsWithPaginationRow 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"` Deleted bool `db:"deleted" json:"deleted"` Createdat sql.NullTime `db:"createdat" json:"createdat"` TotalCount int64 `db:"total_count" json:"total_count"` } func (q *Queries) GetFieldsWithPagination(ctx context.Context, arg GetFieldsWithPaginationParams) ([]GetFieldsWithPaginationRow, 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 []GetFieldsWithPaginationRow for rows.Next() { var i GetFieldsWithPaginationRow if err := rows.Scan( &i.ID, &i.Amoid, &i.Code, &i.Accountid, &i.Name, &i.Entity, &i.Type, &i.Deleted, &i.Createdat, &i.TotalCount, ); 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 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, COUNT(*) OVER() as total_count 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"` } type GetPipelinesWithPaginationRow 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"` Deleted bool `db:"deleted" json:"deleted"` Createdat sql.NullTime `db:"createdat" json:"createdat"` TotalCount int64 `db:"total_count" json:"total_count"` } func (q *Queries) GetPipelinesWithPagination(ctx context.Context, arg GetPipelinesWithPaginationParams) ([]GetPipelinesWithPaginationRow, 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 []GetPipelinesWithPaginationRow for rows.Next() { var i GetPipelinesWithPaginationRow if err := rows.Scan( &i.ID, &i.Amoid, &i.Accountid, &i.Name, &i.Isarchive, &i.Deleted, &i.Createdat, &i.TotalCount, ); 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 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, ); 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 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, ); 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 ` func (q *Queries) GetQuestions(ctx context.Context, quizID int64) ([]Question, error) { rows, err := q.db.QueryContext(ctx, getQuestions, quizID) 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, ); 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' 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 Deleted = false ` func (q *Queries) GetQuizRule(ctx context.Context, quizid int32) (Rule, error) { row := q.db.QueryRowContext(ctx, getQuizRule, quizid) 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 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, COUNT(*) OVER() as total_count FROM steps s JOIN user_data u ON s.AccountID = u.AmoID WHERE s.Deleted = false AND 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"` } type GetStepsWithPaginationRow 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"` Deleted bool `db:"deleted" json:"deleted"` Createdat sql.NullTime `db:"createdat" json:"createdat"` TotalCount int64 `db:"total_count" json:"total_count"` } func (q *Queries) GetStepsWithPagination(ctx context.Context, arg GetStepsWithPaginationParams) ([]GetStepsWithPaginationRow, 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 []GetStepsWithPaginationRow for rows.Next() { var i GetStepsWithPaginationRow if err := rows.Scan( &i.ID, &i.Amoid, &i.Pipelineid, &i.Accountid, &i.Name, &i.Color, &i.Deleted, &i.Createdat, &i.TotalCount, ); 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 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, COUNT(*) OVER() as total_count 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"` } type GetTagsWithPaginationRow struct { ID int64 `db:"id" json:"id"` Amoid int32 `db:"amoid" json:"amoid"` Accountid int32 `db:"accountid" json:"accountid"` Entity interface{} `db:"entity" json:"entity"` Name string `db:"name" json:"name"` Color string `db:"color" json:"color"` Deleted bool `db:"deleted" json:"deleted"` Createdat sql.NullTime `db:"createdat" json:"createdat"` TotalCount int64 `db:"total_count" json:"total_count"` } func (q *Queries) GetTagsWithPagination(ctx context.Context, arg GetTagsWithPaginationParams) ([]GetTagsWithPaginationRow, 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 []GetTagsWithPaginationRow for rows.Next() { var i GetTagsWithPaginationRow if err := rows.Scan( &i.ID, &i.Amoid, &i.Accountid, &i.Entity, &i.Name, &i.Color, &i.Deleted, &i.Createdat, &i.TotalCount, ); 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 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, COUNT(*) OVER() as total_count 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"` } type GetUsersWithPaginationRow struct { ID int64 `db:"id" json:"id"` 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"` Deleted bool `db:"deleted" json:"deleted"` Createdat time.Time `db:"createdat" json:"createdat"` TotalCount int64 `db:"total_count" json:"total_count"` } func (q *Queries) GetUsersWithPagination(ctx context.Context, arg GetUsersWithPaginationParams) ([]GetUsersWithPaginationRow, 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 []GetUsersWithPaginationRow for rows.Next() { var i GetUsersWithPaginationRow if err := rows.Scan( &i.ID, &i.Amoid, &i.Amouserid, &i.Name, &i.Email, &i.Role, &i.Group, &i.Deleted, &i.Createdat, &i.TotalCount, ); 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.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 ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) 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"` } 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, ) 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 }