1238 lines
26 KiB
Go
1238 lines
26 KiB
Go
package accounts
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"slices"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
|
|
"ruben/inventory2/consts"
|
|
)
|
|
|
|
type (
|
|
SyncGroup struct {
|
|
SyncGroupIDs
|
|
Name string
|
|
Listings []SyncGroupListing
|
|
}
|
|
|
|
SyncGroupListing struct {
|
|
SyncGroupIDs
|
|
AccountShopIDs
|
|
ListingID string
|
|
OrderIndex int
|
|
}
|
|
|
|
SyncGroupIDs struct {
|
|
AccountIDs
|
|
SyncGroupID int64
|
|
}
|
|
|
|
// TODO: the id ACTUALLY is the account_id and order_index
|
|
SyncGroupListingDraft struct {
|
|
AccountShopIDs
|
|
ListingID string
|
|
OrderIndex int
|
|
}
|
|
)
|
|
|
|
func (db *Store) CreateSyncGroupListingDraft(ctx context.Context, acctID int64) (orderIndex int, err error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
WITH new_order_index AS (
|
|
SELECT
|
|
COALESCE(MAX(order_index), -1) + 1 AS order_index
|
|
FROM
|
|
sync_group_listing_drafts
|
|
WHERE
|
|
account_id = @account_id
|
|
)
|
|
INSERT INTO
|
|
sync_group_listing_drafts (
|
|
account_id,
|
|
order_index
|
|
)
|
|
SELECT
|
|
@account_id,
|
|
order_index
|
|
FROM
|
|
new_order_index
|
|
RETURNING
|
|
order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if orderIndex, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int]); err != nil {
|
|
return 0, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return orderIndex, nil
|
|
}
|
|
|
|
func (db *Store) CreateMockSyncGroupListingDraft(ctx context.Context, acctID int64) (orderIndex int, err error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
WITH max_order_index(max_index) AS (
|
|
SELECT
|
|
MAX(order_index) AS max_index
|
|
FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
)
|
|
INSERT INTO
|
|
mock.sync_group_listing_draft_order_indexes (
|
|
account_id,
|
|
order_index
|
|
)
|
|
SELECT
|
|
@account_id,
|
|
COALESCE(max_index, -1) + 1
|
|
FROM
|
|
max_order_index
|
|
RETURNING
|
|
order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if orderIndex, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int]); err != nil {
|
|
return 0, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return orderIndex, nil
|
|
}
|
|
|
|
func (db *Store) GetSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int) (SyncGroupListingDraft, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
platform,
|
|
shop_id,
|
|
listing_id
|
|
FROM
|
|
sync_group_listing_drafts
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
r, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[struct {
|
|
Platform *Platform
|
|
Shop_id *string
|
|
Listing_id *string
|
|
Order_index *int
|
|
}])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return SyncGroupListingDraft{}, consts.ErrNotFound
|
|
}
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return SyncGroupListingDraft{
|
|
AccountShopIDs: AccountShopIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Platform: deref(r.Platform),
|
|
ShopID: deref(r.Shop_id),
|
|
},
|
|
ListingID: deref(r.Listing_id),
|
|
OrderIndex: orderIndex,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) GetMockSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int) (SyncGroupListingDraft, error) {
|
|
tx, err := db.db.BeginTx(ctx, pgx.TxOptions{
|
|
AccessMode: pgx.ReadOnly,
|
|
})
|
|
if err != nil {
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to begin transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
true
|
|
FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
if _, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[bool]); err != nil {
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
for _, info := range getAllMockShopSchemaInfos() {
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
shop_id,
|
|
listing_id
|
|
FROM
|
|
%s
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
info.syncGroupListingDraftsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
v, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[struct {
|
|
Shop_id pgtype.Text
|
|
Listing_id pgtype.Text
|
|
}])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
continue
|
|
}
|
|
return SyncGroupListingDraft{}, fmt.Errorf("faild to scan row: %w", err)
|
|
}
|
|
|
|
return SyncGroupListingDraft{
|
|
AccountShopIDs: NewAccountIDs(acctID).
|
|
ShopID(info.platform, v.Shop_id.String),
|
|
ListingID: v.Listing_id.String,
|
|
OrderIndex: orderIndex,
|
|
}, nil
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return SyncGroupListingDraft{}, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return SyncGroupListingDraft{
|
|
AccountShopIDs: NewAccountIDs(acctID).
|
|
ShopID("", ""),
|
|
OrderIndex: orderIndex,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) SetShopInSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int, platform Platform, shopID string) error {
|
|
tag, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
UPDATE
|
|
sync_group_listing_drafts
|
|
SET
|
|
platform = @platform,
|
|
shop_id = @shop_id,
|
|
listing_id = NULL
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
if tag.RowsAffected() != 1 {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) SetShopInMockSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int, platform Platform, shopID string) error {
|
|
info, ok := getMockShopSchemaInfo(platform)
|
|
if !ok {
|
|
return fmt.Errorf("%w: unrecognized platform: %s", consts.ErrNotFound, platform)
|
|
}
|
|
|
|
tx, err := db.db.Begin(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to start transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
RETURNING
|
|
account_id,
|
|
order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query deleting existing index: %w", err)
|
|
}
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.sync_group_listing_draft_order_indexes (
|
|
account_id,
|
|
order_index
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@order_index
|
|
)
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
// TODO: handle error where account doesn't exist?
|
|
return fmt.Errorf("failed to perform query inserting new index: %w", err)
|
|
}
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
INSERT INTO
|
|
%s (
|
|
account_id,
|
|
order_index,
|
|
shop_id
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@order_index,
|
|
@shop_id
|
|
)
|
|
`,
|
|
info.syncGroupListingDraftsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query inserting specific shop index: %w", err)
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) SetListingInSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int, listingID string) error {
|
|
tag, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
UPDATE
|
|
sync_group_listing_drafts
|
|
SET
|
|
listing_id = @listing_id
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
"listing_id": listingID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
if tag.RowsAffected() != 1 {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) SetListingInMockSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int, listingID string) error {
|
|
for _, info := range getAllMockShopSchemaInfos() {
|
|
tag, err := db.db.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
UPDATE
|
|
%s
|
|
SET
|
|
listing_id = @listing_id
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
info.syncGroupListingDraftsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
"listing_id": listingID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if tag.RowsAffected() > 0 {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
func (db *Store) DeleteSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int) (numOfRows int, err error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
WITH deleted_draft AS (
|
|
DELETE FROM
|
|
sync_group_listing_drafts
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
RETURNING
|
|
true AS found
|
|
)
|
|
SELECT
|
|
COUNT(*) as num_rows,
|
|
COALESCE(dd.found, FALSE) as found
|
|
FROM
|
|
sync_group_listing_drafts ld
|
|
LEFT JOIN
|
|
deleted_draft dd
|
|
ON TRUE
|
|
WHERE
|
|
account_id = @account_id
|
|
GROUP BY
|
|
ld.account_id, dd.found
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
type Row struct {
|
|
Found bool
|
|
Num_rows int
|
|
}
|
|
|
|
r, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[Row])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return 0, consts.ErrNotFound
|
|
}
|
|
|
|
return 0, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
if !r.Found {
|
|
return 0, consts.ErrNotFound
|
|
}
|
|
|
|
return r.Num_rows, nil
|
|
}
|
|
|
|
func (db *Store) DeleteMockSyncGroupListingDraft(ctx context.Context, acctID int64, orderIndex int) error {
|
|
tag, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
if tag.RowsAffected() != 1 {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) GetSyncGroupListingDrafts(ctx context.Context, acctID int64) ([]SyncGroupListingDraft, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
order_index,
|
|
platform,
|
|
shop_id,
|
|
listing_id
|
|
FROM
|
|
sync_group_listing_drafts
|
|
WHERE
|
|
account_id = @account_id
|
|
ORDER BY
|
|
order_index ASC
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
type Row struct {
|
|
Order_index int
|
|
Platform *Platform
|
|
Shop_id *string
|
|
Listing_id *string
|
|
}
|
|
|
|
rs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[Row])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
listings := make([]SyncGroupListingDraft, len(rs))
|
|
for i, r := range rs {
|
|
listings[i] = SyncGroupListingDraft{
|
|
AccountShopIDs: AccountShopIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Platform: deref(r.Platform),
|
|
ShopID: deref(r.Shop_id),
|
|
},
|
|
ListingID: deref(r.Listing_id),
|
|
OrderIndex: r.Order_index,
|
|
}
|
|
}
|
|
|
|
slices.SortFunc(listings, func(a, b SyncGroupListingDraft) int {
|
|
return a.OrderIndex - b.OrderIndex
|
|
})
|
|
|
|
return listings, nil
|
|
}
|
|
|
|
func (db *Store) GetMockSyncGroupListingDrafts(ctx context.Context, acctID int64) ([]SyncGroupListingDraft, error) {
|
|
tx, err := db.db.BeginTx(ctx, pgx.TxOptions{
|
|
AccessMode: pgx.ReadOnly,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to begin transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
order_index
|
|
FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
indexes, err := pgx.CollectRows(rows, pgx.RowTo[int])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
listingsByOrderIndex := make(map[int]SyncGroupListingDraft, len(indexes))
|
|
for _, n := range indexes {
|
|
listingsByOrderIndex[n] = SyncGroupListingDraft{
|
|
AccountShopIDs: NewAccountIDs(acctID).
|
|
ShopID("", ""),
|
|
OrderIndex: n,
|
|
}
|
|
}
|
|
|
|
for _, info := range getAllMockShopSchemaInfos() {
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
shop_id,
|
|
order_index,
|
|
listing_id
|
|
FROM
|
|
%s
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
info.syncGroupListingDraftsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Shop_id pgtype.Text
|
|
Order_index pgtype.Int8
|
|
Listing_id pgtype.Text
|
|
}])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
for _, v := range vs {
|
|
n := int(v.Order_index.Int64)
|
|
l := listingsByOrderIndex[n]
|
|
l.Platform = info.platform
|
|
l.ShopID = v.Shop_id.String
|
|
l.ListingID = v.Listing_id.String
|
|
listingsByOrderIndex[n] = l
|
|
}
|
|
}
|
|
|
|
listings := make([]SyncGroupListingDraft, 0, len(listingsByOrderIndex))
|
|
for _, v := range listingsByOrderIndex {
|
|
listings = append(listings, v)
|
|
}
|
|
slices.SortFunc(listings, func(a, b SyncGroupListingDraft) int {
|
|
return a.OrderIndex - b.OrderIndex
|
|
})
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return nil, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return listings, nil
|
|
}
|
|
|
|
func (db *Store) SaveNewSyncGroup(ctx context.Context, acctID int64) (SyncGroup, error) {
|
|
txn, err := db.db.Begin(ctx)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to start transaction: %w", err)
|
|
}
|
|
defer txn.Rollback(ctx)
|
|
|
|
rows, err := txn.Query(
|
|
ctx,
|
|
"SELECT COUNT(*) FROM sync_group_listing_drafts WHERE account_id = @account_id",
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
numDrafts, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[int])
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
if numDrafts < 2 {
|
|
return SyncGroup{}, fmt.Errorf("%w: insufficient listings: must be at least 2: %d", consts.ErrConflict, numDrafts)
|
|
}
|
|
|
|
rows, err = txn.Query(
|
|
ctx,
|
|
`
|
|
WITH deleted_sync_group_listing_drafts AS (
|
|
DELETE FROM
|
|
sync_group_listing_drafts
|
|
WHERE
|
|
account_id = @account_id
|
|
RETURNING
|
|
order_index,
|
|
platform,
|
|
shop_id,
|
|
listing_id
|
|
), new_sync_group AS (
|
|
INSERT INTO
|
|
sync_groups (
|
|
account_id
|
|
)
|
|
VALUES (
|
|
@account_id
|
|
)
|
|
RETURNING
|
|
sync_group_id
|
|
)
|
|
INSERT INTO
|
|
sync_groups_listings (
|
|
sync_group_id,
|
|
order_index,
|
|
platform,
|
|
shop_id,
|
|
listing_id
|
|
)
|
|
SELECT
|
|
sync_group_id,
|
|
order_index,
|
|
platform,
|
|
shop_id,
|
|
listing_id
|
|
FROM
|
|
new_sync_group
|
|
JOIN
|
|
deleted_sync_group_listing_drafts
|
|
ON
|
|
TRUE
|
|
RETURNING
|
|
sync_group_id,
|
|
order_index,
|
|
platform,
|
|
shop_id,
|
|
listing_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
rs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Sync_group_id int64
|
|
Order_index int
|
|
Platform Platform
|
|
Shop_id string
|
|
Listing_id string
|
|
}])
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
if err := txn.Commit(ctx); err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
listings := make([]SyncGroupListing, len(rs))
|
|
for i, r := range rs {
|
|
listings[i] = SyncGroupListing{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: r.Sync_group_id,
|
|
},
|
|
AccountShopIDs: AccountShopIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Platform: r.Platform,
|
|
ShopID: r.Shop_id,
|
|
},
|
|
ListingID: r.Listing_id,
|
|
OrderIndex: r.Order_index,
|
|
}
|
|
}
|
|
|
|
slices.SortFunc(listings, func(a, b SyncGroupListing) int {
|
|
return a.OrderIndex - b.OrderIndex
|
|
})
|
|
|
|
return SyncGroup{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: listings[0].SyncGroupID,
|
|
},
|
|
Listings: listings,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) SaveNewMockSyncGroup(ctx context.Context, acctID int64, name string) (SyncGroup, error) {
|
|
tx, err := db.db.Begin(ctx)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to start transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
// verify there are enough listings
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
COUNT(*)
|
|
FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
numDrafts, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[int])
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
if numDrafts < 2 {
|
|
return SyncGroup{}, fmt.Errorf("%w: insufficient listings: must be at least 2: %d", consts.ErrConflict, numDrafts)
|
|
}
|
|
|
|
// create the new sync group row
|
|
|
|
rows, err = tx.Query(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.sync_groups (
|
|
account_id,
|
|
name
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@name
|
|
)
|
|
RETURNING
|
|
sync_group_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"name": name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query to insert new mock sync group: %w", err)
|
|
}
|
|
|
|
syncGroupID, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64])
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to scan row from inserting new mock sync group: %w", err)
|
|
}
|
|
|
|
// read and delete the draft listings
|
|
|
|
type DraftListingRow struct {
|
|
Order_index int
|
|
Shop_id pgtype.Text
|
|
Listing_id pgtype.Text
|
|
}
|
|
infos := getAllMockShopSchemaInfos()
|
|
newListingsPerPlatform := make(map[Platform][]SyncGroupListing, len(infos))
|
|
var numListings int
|
|
for _, info := range infos {
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
DELETE FROM
|
|
%s
|
|
WHERE
|
|
account_id = @account_id
|
|
RETURNING
|
|
order_index,
|
|
shop_id,
|
|
listing_id
|
|
`,
|
|
info.syncGroupListingDraftsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query deleting mock sync group listing draft order indexes for platform %s: %w", info.platform, err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[DraftListingRow])
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
ls := make([]SyncGroupListing, len(vs))
|
|
for i, v := range vs {
|
|
if !v.Shop_id.Valid {
|
|
return SyncGroup{}, fmt.Errorf("%w: shop_id not specified on listing of order index %d", consts.ErrConflict, v.Order_index)
|
|
}
|
|
if !v.Listing_id.Valid {
|
|
return SyncGroup{}, fmt.Errorf("%w: listing_id not specified on listing of order index %d", consts.ErrConflict, v.Order_index)
|
|
}
|
|
|
|
ls[i] = SyncGroupListing{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: syncGroupID,
|
|
},
|
|
AccountShopIDs: AccountShopIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Platform: info.platform,
|
|
ShopID: v.Shop_id.String,
|
|
},
|
|
ListingID: v.Listing_id.String,
|
|
OrderIndex: v.Order_index,
|
|
}
|
|
}
|
|
|
|
newListingsPerPlatform[info.platform] = ls
|
|
numListings += len(ls)
|
|
}
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_listing_draft_order_indexes
|
|
`,
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query deleting mock sync group listing draft order indexes: %w", err)
|
|
}
|
|
|
|
// create new sync listing rows
|
|
|
|
listings := make([]SyncGroupListing, 0, numListings)
|
|
for _, info := range infos {
|
|
for _, l := range newListingsPerPlatform[info.platform] {
|
|
_, err := tx.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.sync_group_listing_order_indexes (
|
|
sync_group_id,
|
|
order_index
|
|
)
|
|
VALUES (
|
|
@sync_group_id,
|
|
@order_index
|
|
)
|
|
`,
|
|
pgx.NamedArgs{
|
|
"sync_group_id": syncGroupID,
|
|
"order_index": l.OrderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query to insert row into mock.sync_group_listing_order_indexes: %w", err)
|
|
}
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
INSERT INTO
|
|
%s (
|
|
account_id,
|
|
sync_group_id,
|
|
shop_id,
|
|
listing_id,
|
|
order_index
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@sync_group_id,
|
|
@shop_id,
|
|
@listing_id,
|
|
@order_index
|
|
)
|
|
`,
|
|
info.syncGroupListingsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"sync_group_id": syncGroupID,
|
|
"order_index": l.OrderIndex,
|
|
"shop_id": l.ShopID,
|
|
"listing_id": l.ListingID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to perform query to insert row into %s: %w", info.syncGroupListingsTable, err)
|
|
}
|
|
|
|
listings = append(listings, l)
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return SyncGroup{}, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
// prepare return value
|
|
|
|
slices.SortFunc(listings, func(a, b SyncGroupListing) int {
|
|
return a.OrderIndex - b.OrderIndex
|
|
})
|
|
|
|
return SyncGroup{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: syncGroupID,
|
|
},
|
|
Name: name,
|
|
Listings: listings,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) ListMockSyncGroups(ctx context.Context, acctID int64) ([]SyncGroup, error) {
|
|
tx, err := db.db.BeginTx(ctx, pgx.TxOptions{
|
|
AccessMode: pgx.ReadOnly,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to begin transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
sync_group_id,
|
|
name
|
|
FROM
|
|
mock.sync_groups
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Sync_group_id int64
|
|
Name string
|
|
}])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
grps := make([]SyncGroup, len(vs))
|
|
for i, v := range vs {
|
|
listings, err := db.listMockSyncGroupListings(ctx, tx, acctID, v.Sync_group_id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load listings: %w", err)
|
|
}
|
|
|
|
grps[i] = SyncGroup{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: v.Sync_group_id,
|
|
},
|
|
Name: v.Name,
|
|
Listings: listings,
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return nil, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return grps, nil
|
|
}
|
|
|
|
func (db *Store) GetMockSyncGroup(ctx context.Context, acctID, syncGroupID int64) (*SyncGroup, error) {
|
|
tx, err := db.db.BeginTx(ctx, pgx.TxOptions{
|
|
AccessMode: pgx.ReadOnly,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to begin transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
name
|
|
FROM
|
|
mock.sync_groups
|
|
WHERE
|
|
account_id = @account_id
|
|
AND sync_group_id = @sync_group_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"sync_group_id": syncGroupID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
name, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[string])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, consts.ErrNotFound
|
|
}
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
listings, err := db.listMockSyncGroupListings(ctx, tx, acctID, syncGroupID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load listings: %w", err)
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return nil, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return &SyncGroup{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: syncGroupID,
|
|
},
|
|
Name: name,
|
|
Listings: listings,
|
|
}, nil
|
|
}
|
|
|
|
// listMockSyncGroupListings will sort the returned listings by order_index.
|
|
func (db *Store) listMockSyncGroupListings(ctx context.Context, tx pgx.Tx, acctID, syncGroupID int64) ([]SyncGroupListing, error) {
|
|
var listings []SyncGroupListing
|
|
for _, info := range getAllMockShopSchemaInfos() {
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
account_id,
|
|
shop_id,
|
|
listing_id,
|
|
order_index
|
|
FROM
|
|
%s
|
|
WHERE
|
|
account_id = @account_id
|
|
AND sync_group_id = @sync_group_id
|
|
`,
|
|
info.syncGroupListingsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"sync_group_id": syncGroupID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query on %s: %w", info.syncGroupListingsTable, err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Account_id int64
|
|
Shop_id string
|
|
Listing_id string
|
|
Order_index int
|
|
}])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows from %s: %w", info.syncGroupListingsTable, err)
|
|
}
|
|
|
|
for _, v := range vs {
|
|
listings = append(listings, SyncGroupListing{
|
|
SyncGroupIDs: SyncGroupIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
SyncGroupID: syncGroupID,
|
|
},
|
|
AccountShopIDs: AccountShopIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Platform: info.platform,
|
|
ShopID: v.Shop_id,
|
|
},
|
|
ListingID: v.Listing_id,
|
|
OrderIndex: v.Order_index,
|
|
})
|
|
}
|
|
}
|
|
|
|
slices.SortFunc(listings, func(a, b SyncGroupListing) int {
|
|
return a.OrderIndex - b.OrderIndex
|
|
})
|
|
|
|
return listings, nil
|
|
}
|