This commit is contained in:
Pavel 2024-04-18 23:05:49 +03:00
parent 460f903f3e
commit 07644bfbf0
2 changed files with 176 additions and 249 deletions

@ -696,28 +696,7 @@ SELECT *, COUNT(*) OVER() as total_count FROM pipelines WHERE Deleted = false O
-- name: GetFieldsWithPagination :many
SELECT *, COUNT(*) OVER() as total_count FROM fields WHERE Deleted = false ORDER BY ID OFFSET ($1 - 1) * $2 LIMIT $2;
-- name: CheckTags :many
WITH user_data AS (
SELECT AmoID
FROM users
WHERE users.AccountID = $1
),
insert AS (
INSERT INTO tags (amoID, accountID, Entity, name, color, createdAt)
SELECT (new_tags->>'AmoID')::INT,
user_data.AmoID,
CAST(new_tags->>'Entity' AS entitytype),
COALESCE(new_tags->>'Name', '')::varchar(50),
COALESCE(new_tags->>'Color', '')::varchar(50),
CURRENT_TIMESTAMP
FROM json_array_elements($2::json) AS new_tags
JOIN user_data ON true
ON CONFLICT (amoID, accountID, entity) DO NOTHING
RETURNING EXCLUDED.*
)
SELECT * FROM insert;
-- name: UpdateTags :json_array
-- name: UpdateTags :exec
UPDATE tags AS t
SET name = (update_data ->> 'Name')::varchar(50),
color = (update_data ->> 'Color')::varchar(50),
@ -727,21 +706,6 @@ WHERE t.amoID = (update_data ->> 'AmoID')::INT
AND t.accountID = (update_data ->> 'AccountID')::INT
AND t.Entity = (update_data ->> 'Entity')::entitytype;
-- name: CheckPipelines :many
WITH insert AS (
INSERT INTO pipelines (amoID, accountID, name, isArchive, createdAt)
SELECT (new_pipelines->>'AmoID')::INT,
(new_pipelines->>'AccountID')::INT,
COALESCE(new_pipelines->>'Name', '')::varchar(50),
CASE WHEN (new_pipelines->>'IsArchive') = 'true' THEN TRUE ELSE FALSE END,
CURRENT_TIMESTAMP
FROM json_array_elements($1::json) AS new_pipelines
ON CONFLICT (amoID, accountID) DO NOTHING
RETURNING EXCLUDED.*
)
SELECT * FROM insert;
-- name: UpdatePipelines :exec
UPDATE pipelines AS p
SET name = (update_data ->> 'Name')::varchar(50),
@ -751,22 +715,6 @@ FROM json_array_elements($1::json) AS update_data
WHERE p.amoID = (update_data ->> 'AmoID')::INT
AND p.accountID = (update_data ->> 'AccountID')::INT;
-- name: CheckSteps :many
WITH insert AS (
INSERT INTO steps (amoID, pipelineID, accountID, name, color, createdAt)
SELECT (new_steps->>'AmoID')::INT,
(new_steps->>'PipelineID')::INT,
(new_steps->>'AccountID')::INT,
COALESCE(new_steps->>'Name', '')::varchar(50),
COALESCE(new_steps->>'Color', '')::varchar(50),
CURRENT_TIMESTAMP
FROM json_array_elements($1::json) AS new_steps
ON CONFLICT (amoID, accountID, PipelineID) DO NOTHING
RETURNING EXCLUDED.*
)
SELECT * FROM insert;
-- name: UpdateSteps :exec
UPDATE steps AS s
SET name = (update_data ->> 'Name')::varchar(50),
@ -777,29 +725,6 @@ WHERE s.amoID = (update_data ->> 'AmoID')::INT
AND s.accountID = (update_data ->> 'AccountID')::INT
AND s.pipelineID = (update_data ->> 'PipelineID')::INT;
-- name: CheckFields :many
WITH user_data AS (
SELECT AmoID
FROM users
WHERE users.AccountID = $1
),
insert AS (
INSERT INTO fields (amoID, code, accountID, name, Entity, type, createdAt)
SELECT (new_fields->>'AmoID')::INT,
COALESCE(new_fields->>'Code', '')::varchar(255),
user_data.AmoID,
COALESCE(new_fields->>'Name', '')::varchar(50),
CAST(new_fields->>'Entity' AS entitytype),
COALESCE(new_fields->>'Type', '')::varchar(50),
CURRENT_TIMESTAMP
FROM json_array_elements($2::json) AS new_fields
JOIN user_data ON true
ON CONFLICT (amoID, accountID, entity) DO NOTHING
RETURNING EXCLUDED.*
)
SELECT * FROM insert;
-- name: UpdateFields :exec
UPDATE fields AS f
SET name = (update_data ->> 'Name')::varchar(50),
@ -810,3 +735,81 @@ 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;
-- name: CheckTags :many
WITH user_data AS (
SELECT AmoID
FROM users
WHERE users.AccountID = $1
), new_tags AS (
SELECT (tag->>'AmoID')::INT AS amoID,
(tag->>'Entity')::entitytype AS Entity,
COALESCE(tag->>'Name', '')::VARCHAR(50) 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 NOTHING
RETURNING *
)
SELECT * FROM inserted_tags;
-- -- name: CheckPipelines :many
-- WITH insertt AS (
-- INSERT INTO pipelines (amoID, accountID, name, isArchive, createdAt)
-- SELECT (new_pipelines->>'AmoID')::INT,
-- (new_pipelines->>'AccountID')::INT,
-- COALESCE(new_pipelines->>'Name', '')::varchar(50),
-- CASE WHEN (new_pipelines->>'IsArchive') = 'true' THEN TRUE ELSE FALSE END,
-- CURRENT_TIMESTAMP
-- FROM json_array_elements($1::json) AS new_pipelines
-- ON CONFLICT (amoID, accountID) DO NOTHING
-- RETURNING EXCLUDED.*
-- )
-- SELECT * FROM insertt;
--
-- -- name: CheckFields :many
-- WITH user_data AS (
-- SELECT AmoID
-- FROM users
-- WHERE users.AccountID = $1
-- ),
-- insertt AS (
-- INSERT INTO fields (amoID, code, accountID, name, Entity, type, createdAt)
-- SELECT (new_fields->>'AmoID')::INT,
-- COALESCE(new_fields->>'Code', '')::varchar(255),
-- user_data.AmoID,
-- COALESCE(new_fields->>'Name', '')::varchar(50),
-- CAST(new_fields->>'Entity' AS entitytype),
-- COALESCE(new_fields->>'Type', '')::varchar(50),
-- CURRENT_TIMESTAMP
-- FROM json_array_elements($2::json) AS new_fields
-- JOIN user_data ON true
-- ON CONFLICT (amoID, accountID, entity) DO NOTHING
-- RETURNING EXCLUDED.*
-- )
-- SELECT * FROM insertt;
--
-- -- name: CheckSteps :many
-- WITH insertt AS (
-- INSERT INTO steps (amoID, pipelineID, accountID, name, color, createdAt)
-- SELECT (new_steps->>'AmoID')::INT,
-- (new_steps->>'PipelineID')::INT,
-- (new_steps->>'AccountID')::INT,
-- COALESCE(new_steps->>'Name', '')::varchar(50),
-- COALESCE(new_steps->>'Color', '')::varchar(50),
-- CURRENT_TIMESTAMP
-- FROM json_array_elements($1::json) AS new_steps
-- ON CONFLICT (amoID, accountID, PipelineID) DO NOTHING
-- RETURNING EXCLUDED.*
-- )
-- SELECT * FROM insertt;

@ -167,114 +167,6 @@ func (q *Queries) CheckExpired(ctx context.Context) ([]Token, error) {
return items, nil
}
const checkFields = `-- name: CheckFields :many
WITH user_data AS (
SELECT AmoID
FROM users
WHERE users.AccountID = $1
)
INSERT INTO fields (amoID, code, accountID, name, Entity, type, createdAt)
SELECT (new_fields->>'AmoID')::INT,
COALESCE(new_fields->>'Code', '')::varchar(255),
user_data.AmoID,
COALESCE(new_fields->>'Name', '')::varchar(50),
CAST(new_fields->>'Entity' AS entitytype),
COALESCE(new_fields->>'Type', '')::varchar(50),
CURRENT_TIMESTAMP
FROM json_array_elements($2::json) AS new_fields
JOIN user_data ON true
ON CONFLICT (amoID, accountID, entity) DO UPDATE
SET name = CASE WHEN fields.name <> EXCLUDED.name THEN EXCLUDED.name ELSE fields.name END,
code = CASE WHEN fields.code <> EXCLUDED.code THEN EXCLUDED.code ELSE fields.code END,
type = CASE WHEN fields.type <> EXCLUDED.type THEN EXCLUDED.type ELSE fields.type END,
createdAt = CASE WHEN fields.createdAt <> CURRENT_TIMESTAMP THEN CURRENT_TIMESTAMP ELSE fields.createdAt END
RETURNING id, amoid, code, accountid, name, entity, type, deleted, createdat
`
type CheckFieldsParams struct {
Accountid string `db:"accountid" json:"accountid"`
Column2 json.RawMessage `db:"column_2" json:"column_2"`
}
func (q *Queries) CheckFields(ctx context.Context, arg CheckFieldsParams) ([]Field, error) {
rows, err := q.db.QueryContext(ctx, checkFields, arg.Accountid, arg.Column2)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Field
for rows.Next() {
var i Field
if err := rows.Scan(
&i.ID,
&i.Amoid,
&i.Code,
&i.Accountid,
&i.Name,
&i.Entity,
&i.Type,
&i.Deleted,
&i.Createdat,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const checkPipelines = `-- name: CheckPipelines :many
INSERT INTO pipelines (amoID, accountID, name, isArchive, createdAt)
SELECT (new_pipelines->>'AmoID')::INT,
(new_pipelines->>'AccountID')::INT,
COALESCE(new_pipelines->>'Name', '')::varchar(50),
CASE WHEN (new_pipelines->>'IsArchive') = 'true' THEN TRUE ELSE FALSE END,
CURRENT_TIMESTAMP
FROM json_array_elements($1::json) AS new_pipelines
ON CONFLICT (amoID, accountID) DO UPDATE
SET name = CASE WHEN pipelines.name <> EXCLUDED.name THEN EXCLUDED.name ELSE pipelines.name END,
isArchive = CASE WHEN pipelines.isArchive <> EXCLUDED.isArchive THEN EXCLUDED.isArchive ELSE pipelines.isArchive END,
createdAt = CASE WHEN pipelines.createdAt <> CURRENT_TIMESTAMP THEN CURRENT_TIMESTAMP ELSE pipelines.createdAt END
RETURNING id, amoid, accountid, name, isarchive, deleted, createdat
`
func (q *Queries) CheckPipelines(ctx context.Context, dollar_1 json.RawMessage) ([]Pipeline, error) {
rows, err := q.db.QueryContext(ctx, checkPipelines, dollar_1)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Pipeline
for rows.Next() {
var i Pipeline
if err := rows.Scan(
&i.ID,
&i.Amoid,
&i.Accountid,
&i.Name,
&i.Isarchive,
&i.Deleted,
&i.Createdat,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const 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
`
@ -321,74 +213,31 @@ func (q *Queries) CheckResultsOwner(ctx context.Context, arg CheckResultsOwnerPa
return items, nil
}
const checkSteps = `-- name: CheckSteps :many
INSERT INTO steps (amoID,pipelineID, accountID, name, color, createdAt)
SELECT (new_steps->>'AmoID')::INT,
(new_steps->>'PipelineID')::INT,
(new_steps->>'AccountID')::INT,
COALESCE(new_steps->>'Name', '')::varchar(50),
COALESCE(new_steps->>'Color', '')::varchar(50),
CURRENT_TIMESTAMP
FROM json_array_elements($1::json) AS new_steps
ON CONFLICT (amoID, accountID, PipelineID) DO UPDATE
SET name = CASE WHEN steps.name <> EXCLUDED.name THEN EXCLUDED.name ELSE steps.name END,
color = CASE WHEN steps.color <> EXCLUDED.color THEN EXCLUDED.color ELSE steps.color END,
createdAt = CASE WHEN steps.createdAt <> CURRENT_TIMESTAMP THEN CURRENT_TIMESTAMP ELSE steps.createdAt END
RETURNING id, amoid, pipelineid, accountid, name, color, deleted, createdat
`
func (q *Queries) CheckSteps(ctx context.Context, dollar_1 json.RawMessage) ([]Step, error) {
rows, err := q.db.QueryContext(ctx, checkSteps, dollar_1)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Step
for rows.Next() {
var i Step
if err := rows.Scan(
&i.ID,
&i.Amoid,
&i.Pipelineid,
&i.Accountid,
&i.Name,
&i.Color,
&i.Deleted,
&i.Createdat,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const checkTags = `-- name: CheckTags :many
WITH user_data AS (
SELECT AmoID
FROM users
WHERE users.AccountID = $1
), new_tags AS (
SELECT (tag->>'AmoID')::INT AS amoID,
(tag->>'Entity')::entitytype AS Entity,
COALESCE(tag->>'Name', '')::VARCHAR(50) 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 NOTHING
RETURNING id, amoid, accountid, entity, name, color, deleted, createdat
)
INSERT INTO tags (amoID, accountID, Entity, name, color, createdAt)
SELECT (new_tags->>'AmoID')::INT,
user_data.AmoID,
CAST(new_tags->>'Entity' AS entitytype),
COALESCE(new_tags->>'Name', '')::varchar(50),
COALESCE(new_tags->>'Color', '')::varchar(50),
CURRENT_TIMESTAMP
FROM json_array_elements($2::json) AS new_tags
JOIN user_data ON true
ON CONFLICT (amoID, accountID, entity) DO UPDATE
SET name = CASE WHEN tags.name <> EXCLUDED.name THEN EXCLUDED.name ELSE tags.name END,
color = CASE WHEN tags.color <> EXCLUDED.color THEN EXCLUDED.color ELSE tags.color END,
createdAt = CASE WHEN tags.createdAt <> CURRENT_TIMESTAMP THEN CURRENT_TIMESTAMP ELSE tags.createdAt END
RETURNING id, amoid, accountid, entity, name, color, deleted, createdat
SELECT id, amoid, accountid, entity, name, color, deleted, createdat FROM inserted_tags
`
type CheckTagsParams struct {
@ -396,15 +245,26 @@ type CheckTagsParams struct {
Column2 json.RawMessage `db:"column_2" json:"column_2"`
}
func (q *Queries) CheckTags(ctx context.Context, arg CheckTagsParams) ([]Tag, error) {
type CheckTagsRow 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"`
}
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 []Tag
var items []CheckTagsRow
for rows.Next() {
var i Tag
var i CheckTagsRow
if err := rows.Scan(
&i.ID,
&i.Amoid,
@ -2551,6 +2411,38 @@ func (q *Queries) SoftDeleteResultByID(ctx context.Context, id int64) error {
return err
}
const updateFields = `-- name: UpdateFields :exec
UPDATE fields AS f
SET name = (update_data ->> 'Name')::varchar(50),
code = (update_data ->> 'Code')::varchar(255),
type = (update_data ->> 'Type')::varchar(50),
createdAt = CURRENT_TIMESTAMP
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(50),
isArchive = CASE WHEN (update_data ->> 'IsArchive') = 'true' THEN TRUE ELSE FALSE END,
createdAt = CURRENT_TIMESTAMP
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
`
@ -2586,6 +2478,38 @@ func (q *Queries) UpdatePrivilegeAmount(ctx context.Context, arg UpdatePrivilege
return err
}
const updateSteps = `-- name: UpdateSteps :exec
UPDATE steps AS s
SET name = (update_data ->> 'Name')::varchar(50),
color = (update_data ->> 'Color')::varchar(50),
createdAt = CURRENT_TIMESTAMP
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(50),
color = (update_data ->> 'Color')::varchar(50),
createdAt = CURRENT_TIMESTAMP
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 webhookDelete = `-- name: WebhookDelete :exec
DELETE FROM tokens WHERE AccountID = $1
`