1816 lines
38 KiB
Go
1816 lines
38 KiB
Go
package accounts
|
|
|
|
// to generate StoreWithContext
|
|
//go:generate concurry -s Store
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"ruben/inventory2/consts"
|
|
"ruben/inventory2/logging"
|
|
)
|
|
|
|
type (
|
|
Store struct {
|
|
log *logging.Logger
|
|
db *pgxpool.Pool
|
|
}
|
|
|
|
Account struct {
|
|
AccountIDs
|
|
OAuthUser
|
|
Email string
|
|
}
|
|
|
|
OAuthUser struct {
|
|
UserID string
|
|
}
|
|
|
|
AccountShop struct {
|
|
AccountShopIDs
|
|
Name string
|
|
}
|
|
|
|
Listing struct {
|
|
AccountShopListingIDs
|
|
ShopName string
|
|
SKU string
|
|
Name string
|
|
Description string
|
|
Count int64
|
|
}
|
|
|
|
ListingWithOrderIndex struct {
|
|
Listing
|
|
OrderIndex int
|
|
}
|
|
)
|
|
|
|
func NewStore(logger *logging.Logger, db *pgxpool.Pool) *Store {
|
|
return &Store{
|
|
log: logger,
|
|
db: db,
|
|
}
|
|
}
|
|
|
|
func (db *Store) WithContext(ctx context.Context) *StoreWithContext {
|
|
return NewStoreWithContext(ctx, db)
|
|
}
|
|
|
|
func (db *Store) CreateAccount(ctx context.Context, userID, email string) (Account, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
INSERT INTO accounts (
|
|
user_id,
|
|
email
|
|
)
|
|
VALUES (
|
|
@user_id,
|
|
@email
|
|
)
|
|
ON CONFLICT DO NOTHING
|
|
RETURNING
|
|
account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"user_id": userID,
|
|
"email": email,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return Account{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
acctID, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return Account{}, fmt.Errorf("account already exists: %w", consts.ErrConflict)
|
|
}
|
|
return Account{}, fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
return Account{
|
|
OAuthUser: OAuthUser{
|
|
UserID: userID,
|
|
},
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Email: email,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) GetAccount(ctx context.Context, id int64) (Account, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
"SELECT email, user_id FROM accounts WHERE account_id = @account_id",
|
|
pgx.NamedArgs{
|
|
"account_id": id,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return Account{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
type Row struct {
|
|
Email string
|
|
User_id string
|
|
}
|
|
|
|
r, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[Row])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return Account{}, consts.ErrNotFound
|
|
}
|
|
|
|
return Account{}, fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
return Account{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: id,
|
|
},
|
|
OAuthUser: OAuthUser{
|
|
r.User_id,
|
|
},
|
|
Email: r.Email,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) GetAccountByUserID(ctx context.Context, userID string) (Account, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`SELECT
|
|
email, account_id
|
|
FROM
|
|
accounts
|
|
WHERE
|
|
user_id = @user_id`,
|
|
pgx.NamedArgs{
|
|
"user_id": userID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return Account{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
type Row struct {
|
|
Email string
|
|
Account_ID int64
|
|
}
|
|
|
|
r, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[Row])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return Account{}, consts.ErrNotFound
|
|
}
|
|
|
|
return Account{}, fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
return Account{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: r.Account_ID,
|
|
},
|
|
OAuthUser: OAuthUser{
|
|
UserID: userID,
|
|
},
|
|
Email: r.Email,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) GetAccountByEmail(ctx context.Context, email string) (Account, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
"SELECT account_id, user_id FROM accounts WHERE email = @email",
|
|
pgx.NamedArgs{
|
|
"email": email,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return Account{}, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
type Row struct {
|
|
Account_id int64
|
|
User_id string
|
|
}
|
|
|
|
r, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[Row])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return Account{}, consts.ErrNotFound
|
|
}
|
|
|
|
return Account{}, fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
return Account{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: r.Account_id,
|
|
},
|
|
OAuthUser: OAuthUser{
|
|
UserID: r.User_id,
|
|
},
|
|
Email: email,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) GetAccountIDByMockPlatformAndShopID(ctx context.Context, platform Platform, shopID string) (int64, error) {
|
|
info, ok := getMockShopSchemaInfo(platform)
|
|
if !ok {
|
|
return 0, fmt.Errorf("unrecognized platform: %w", consts.ErrNotFound)
|
|
}
|
|
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
account_id
|
|
FROM
|
|
%s
|
|
WHERE
|
|
shop_id = @shop_id
|
|
`,
|
|
info.shopTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
acctID, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return 0, consts.ErrNotFound
|
|
}
|
|
return 0, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return acctID, nil
|
|
}
|
|
|
|
func (db *Store) GetUserAndAccountByAccessToken(ctx context.Context, accessToken string) (OAuthUser, *Account, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
u.user_id,
|
|
a.account_id,
|
|
a.email
|
|
FROM oauth_users u
|
|
LEFT JOIN oauth_tokens t
|
|
ON u.user_id = id_token_subject
|
|
LEFT JOIN accounts a
|
|
USING (user_id)
|
|
WHERE access_token = @access_token
|
|
`,
|
|
pgx.NamedArgs{
|
|
"access_token": accessToken,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return OAuthUser{}, nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
type Row struct {
|
|
User_ID string
|
|
Account_ID *int64
|
|
Email *string
|
|
}
|
|
|
|
r, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[Row])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return OAuthUser{}, nil, consts.ErrNotFound
|
|
}
|
|
return OAuthUser{}, nil, fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
user := OAuthUser{UserID: r.User_ID}
|
|
|
|
var acct *Account
|
|
if r.Account_ID != nil {
|
|
acct = &Account{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: *r.Account_ID,
|
|
},
|
|
OAuthUser: user,
|
|
Email: *r.Email,
|
|
}
|
|
}
|
|
|
|
return user, acct, nil
|
|
}
|
|
|
|
func (db *Store) GetShops(ctx context.Context, acctID int64) ([]AccountShop, error) {
|
|
var shops []AccountShop
|
|
for _, v := range getDevShops(acctID) {
|
|
shops = append(shops, v)
|
|
}
|
|
|
|
return shops, nil
|
|
}
|
|
|
|
func (db *Store) GetMockShops(ctx context.Context, acctID int64) ([]AccountShop, error) {
|
|
infos := getAllMockShopSchemaInfos()
|
|
lists := make([][]AccountShop, len(infos))
|
|
numShops := 0
|
|
|
|
for i, in := range infos {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
shop_id,
|
|
name
|
|
FROM
|
|
%s
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
in.shopTable,
|
|
),
|
|
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 string
|
|
Name string
|
|
}])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
list := make([]AccountShop, len(vs))
|
|
for i, v := range vs {
|
|
list[i] = AccountShop{
|
|
AccountShopIDs: NewAccountIDs(acctID).
|
|
ShopID(in.platform, v.Shop_id),
|
|
Name: v.Name,
|
|
}
|
|
}
|
|
|
|
lists[i] = list
|
|
numShops += len(list)
|
|
}
|
|
|
|
shops := make([]AccountShop, 0, numShops)
|
|
for _, list := range lists {
|
|
shops = append(shops, list...)
|
|
}
|
|
|
|
return shops, nil
|
|
}
|
|
|
|
func (db *Store) GetListingsForShop(ctx context.Context, acctID int64, platform Platform, shopID string) ([]Listing, error) {
|
|
var vs []Listing
|
|
for _, v := range getDevListings(acctID) {
|
|
if v.Platform != platform {
|
|
continue
|
|
}
|
|
if v.ShopID != shopID {
|
|
continue
|
|
}
|
|
vs = append(vs, v)
|
|
}
|
|
|
|
return vs, nil
|
|
}
|
|
|
|
func (db *Store) GetMockListingsForShop(ctx context.Context, acctID int64, platform Platform, shopID string) ([]Listing, error) {
|
|
in, ok := getMockShopSchemaInfo(platform)
|
|
if !ok {
|
|
return nil, consts.ErrNotFound
|
|
}
|
|
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
sh.name as shop_name,
|
|
li.listing_id,
|
|
li.sku,
|
|
li.name,
|
|
li.description,
|
|
li."count"
|
|
FROM
|
|
%s as sh
|
|
JOIN
|
|
%s as li
|
|
USING
|
|
(account_id, shop_id)
|
|
WHERE
|
|
account_id = @account_id
|
|
AND shop_id = @shop_id
|
|
`,
|
|
in.shopTable,
|
|
in.listingsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Shop_name string
|
|
Listing_id string
|
|
SKU string
|
|
Name string
|
|
Description string
|
|
Count int64
|
|
}])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
listings := make([]Listing, len(vs))
|
|
for i, v := range vs {
|
|
listings[i] = Listing{
|
|
AccountShopListingIDs: NewAccountIDs(acctID).
|
|
ShopID(in.platform, shopID).
|
|
ListingID(v.Listing_id),
|
|
ShopName: v.Shop_name,
|
|
SKU: v.SKU,
|
|
Name: v.Name,
|
|
Description: v.Description,
|
|
Count: v.Count,
|
|
}
|
|
}
|
|
|
|
return listings, nil
|
|
}
|
|
|
|
func (db *Store) GetMockListing(ctx context.Context, acctID int64, platform Platform, shopID, listingID string) (*Listing, error) {
|
|
in, ok := getMockShopSchemaInfo(platform)
|
|
if !ok {
|
|
return nil, fmt.Errorf("%w: unrecognized platform: %s", consts.ErrNotFound, platform)
|
|
}
|
|
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
sh.name as shop_name,
|
|
li.name,
|
|
li.count,
|
|
li.sku,
|
|
li.description
|
|
FROM
|
|
%s AS sh
|
|
JOIN
|
|
%s AS li
|
|
USING
|
|
(account_id, shop_id)
|
|
WHERE
|
|
account_id = @account_id
|
|
AND shop_id = @shop_id
|
|
AND listing_id = @listing_id
|
|
`,
|
|
in.shopTable,
|
|
in.listingsTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"shop_id": shopID,
|
|
"listing_id": listingID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
v, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[struct {
|
|
Shop_name string
|
|
Name string
|
|
Count int64
|
|
Sku string
|
|
Description string
|
|
}])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, consts.ErrNotFound
|
|
}
|
|
return nil, fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
return &Listing{
|
|
AccountShopListingIDs: AccountShopListingIDs{
|
|
AccountShopIDs: AccountShopIDs{
|
|
AccountIDs: AccountIDs{
|
|
AccountID: acctID,
|
|
},
|
|
Platform: platform,
|
|
ShopID: shopID,
|
|
},
|
|
ListingID: listingID,
|
|
},
|
|
ShopName: v.Shop_name,
|
|
SKU: v.Sku,
|
|
Name: v.Name,
|
|
Description: v.Name,
|
|
Count: v.Count,
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) DeleteMockSyncGroup(ctx context.Context, acctID, syncGroupID int64) error {
|
|
tag, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
DELETE 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 fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) StartEditingMockSyncGroup(ctx context.Context, acctID, syncGroupID int64) (prevSyncGroupID int64, prevSyncGroupExists bool, err error) {
|
|
tx, err := db.db.Begin(ctx)
|
|
if err != nil {
|
|
return 0, false, fmt.Errorf("failed to begin transaction: %w", err)
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
WITH deleted_row AS (
|
|
DELETE FROM
|
|
mock.sync_group_editing
|
|
WHERE
|
|
account_id = @account_id
|
|
AND sync_group_id <> @sync_group_id
|
|
RETURNING
|
|
account_id,
|
|
sync_group_id
|
|
), new_row AS (
|
|
INSERT INTO
|
|
mock.sync_group_editing (
|
|
account_id,
|
|
sync_group_id
|
|
)
|
|
SELECT
|
|
x.account_id,
|
|
x.sync_group_id
|
|
FROM (
|
|
VALUES (
|
|
@account_id,
|
|
@sync_group_id
|
|
)
|
|
) AS x(account_id, sync_group_id)
|
|
LEFT JOIN
|
|
deleted_row
|
|
ON
|
|
TRUE
|
|
ON CONFLICT
|
|
DO NOTHING
|
|
)
|
|
SELECT
|
|
sync_group_id
|
|
FROM
|
|
deleted_row
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"sync_group_id": syncGroupID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, false, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
v, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[pgtype.Int8])
|
|
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
|
|
return 0, false, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
// insert the mock sync group listings into the draft table
|
|
|
|
for _, in := range getAllMockShopSchemaInfos() {
|
|
_, err := tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
WITH existing_listings AS (
|
|
SELECT
|
|
shop_id,
|
|
listing_id,
|
|
order_index
|
|
FROM
|
|
%s
|
|
WHERE
|
|
account_id = @account_id
|
|
AND sync_group_id = @sync_group_id
|
|
), inserted_order_indexes AS (
|
|
INSERT INTO
|
|
mock.sync_group_editing_listing_order_indexes (
|
|
account_id,
|
|
order_index
|
|
)
|
|
SELECT
|
|
@account_id,
|
|
order_index
|
|
FROM
|
|
existing_listings
|
|
RETURNING
|
|
order_index
|
|
)
|
|
INSERT INTO
|
|
%s (
|
|
account_id,
|
|
shop_id,
|
|
listing_id,
|
|
order_index
|
|
)
|
|
SELECT
|
|
@account_id,
|
|
shop_id,
|
|
listing_id,
|
|
order_index
|
|
FROM
|
|
existing_listings
|
|
JOIN
|
|
inserted_order_indexes
|
|
USING
|
|
(order_index)
|
|
`,
|
|
in.syncGroupListingsTable,
|
|
in.syncGroupEditingListingTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"sync_group_id": syncGroupID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, false, fmt.Errorf("failed to insert into editing listings table: %w", err)
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return 0, false, fmt.Errorf("failed to commit transaction: %w", err)
|
|
}
|
|
|
|
return v.Int64, v.Valid, nil
|
|
}
|
|
|
|
func (db *Store) SaveMockSyncGroupBeingEdited(ctx context.Context, acctID int64) (syncGroupID int64, err error) {
|
|
err = db.beginTxn(ctx, func(tx pgx.Tx) error {
|
|
// delete old sync group listings
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
WITH the_sync_group AS (
|
|
SELECT
|
|
sync_group_id
|
|
FROM
|
|
mock.sync_group_editing
|
|
WHERE
|
|
account_id = @account_id
|
|
), deleted_indexes AS (
|
|
DELETE FROM
|
|
mock.sync_group_listing_order_indexes ind
|
|
USING
|
|
mock.sync_group_editing AS ed
|
|
WHERE
|
|
ed.account_id = @account_id
|
|
AND ind.sync_group_id = ed.sync_group_id
|
|
RETURNING
|
|
ed.sync_group_id
|
|
)
|
|
SELECT
|
|
sync_group_id
|
|
FROM
|
|
deleted_indexes
|
|
LIMIT
|
|
1
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to query editing sync group: %w", err)
|
|
}
|
|
|
|
if syncGroupID, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64]); err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return consts.ErrNotFound
|
|
}
|
|
return fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
var listingCount int
|
|
for _, in := range getAllMockShopSchemaInfos() {
|
|
// look up edited sync group listings
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
order_index,
|
|
shop_id,
|
|
listing_id
|
|
FROM
|
|
%s el
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
in.syncGroupEditingListingTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Order_index int
|
|
Shop_id pgtype.Text
|
|
Listing_id pgtype.Text
|
|
}])
|
|
if err != nil {
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
if len(vs) == 0 {
|
|
continue
|
|
}
|
|
|
|
// fail if any shop_id's or listing_id's are NULL
|
|
for _, v := range vs {
|
|
if !v.Shop_id.Valid {
|
|
return fmt.Errorf("%w: shop id missing on listing", consts.ErrConflict)
|
|
}
|
|
if !v.Listing_id.Valid {
|
|
return fmt.Errorf("%w: listing id missing on listing", consts.ErrConflict)
|
|
}
|
|
}
|
|
|
|
// create new sync group listing order indexes
|
|
|
|
values := make([]string, len(vs))
|
|
args := make(pgx.NamedArgs, len(vs))
|
|
for i, v := range vs {
|
|
values[i] = fmt.Sprintf("(@sync_group_id_%[1]d, @order_index_%[1]d)", i)
|
|
args[fmt.Sprintf("sync_group_id_%d", i)] = syncGroupID
|
|
args[fmt.Sprintf("order_index_%d", i)] = v.Order_index
|
|
}
|
|
listingCount += len(vs)
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
INSERT INTO
|
|
mock.sync_group_listing_order_indexes (
|
|
sync_group_id,
|
|
order_index
|
|
)
|
|
VALUES
|
|
%s
|
|
`,
|
|
strings.Join(values, ", "),
|
|
),
|
|
args,
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete rows for sync group listing order indexes: %w", err)
|
|
}
|
|
|
|
// create new sync group listings
|
|
|
|
values = make([]string, len(vs))
|
|
args = make(pgx.NamedArgs, len(vs))
|
|
for i, v := range vs {
|
|
values[i] = fmt.Sprintf("(@account_id_%[1]d, @sync_group_id_%[1]d, @shop_id_%[1]d, @listing_id_%[1]d, @order_index_%[1]d)", i)
|
|
args[fmt.Sprintf("account_id_%d", i)] = acctID
|
|
args[fmt.Sprintf("sync_group_id_%d", i)] = syncGroupID
|
|
args[fmt.Sprintf("shop_id_%d", i)] = v.Shop_id
|
|
args[fmt.Sprintf("listing_id_%d", i)] = v.Listing_id
|
|
args[fmt.Sprintf("order_index_%d", i)] = v.Order_index
|
|
}
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
INSERT INTO
|
|
%s (
|
|
account_id,
|
|
sync_group_id,
|
|
shop_id,
|
|
listing_id,
|
|
order_index
|
|
)
|
|
VALUES
|
|
%s
|
|
`,
|
|
in.syncGroupListingsTable,
|
|
strings.Join(values, ", "),
|
|
),
|
|
args,
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query inserting new sync group listings: %w", err)
|
|
}
|
|
}
|
|
|
|
// there must be at least two listings per sync group
|
|
|
|
if listingCount < 2 {
|
|
return fmt.Errorf("%w: invalid number of listings for sync group: %d: minimum of two required", consts.ErrConflict, listingCount)
|
|
}
|
|
|
|
// delete the sync group editing record
|
|
// this will cascade the editing listing records
|
|
|
|
rows, err = tx.Query(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_editing
|
|
WHERE
|
|
account_id = @account_id
|
|
RETURNING
|
|
sync_group_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query deleting editing sync group: %w", err)
|
|
}
|
|
|
|
if syncGroupID, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64]); err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return consts.ErrNotFound
|
|
}
|
|
return fmt.Errorf("failed to scan row: %w", err)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
return syncGroupID, err
|
|
}
|
|
|
|
func (db *Store) CancelEditingOfMockSyncGroupForAccount(ctx context.Context, acctID int64) (prevSyncGroupID int64, prevSyncGroupExists bool, err error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_editing
|
|
WHERE
|
|
account_id = @account_id
|
|
RETURNING
|
|
sync_group_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return 0, false, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
prevSyncGroupID, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return 0, false, nil
|
|
}
|
|
return 0, false, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return prevSyncGroupID, true, nil
|
|
}
|
|
|
|
func (db *Store) GetMockSyncGroupEditingListings(ctx context.Context, acctID int64) ([]ListingWithOrderIndex, error) {
|
|
var (
|
|
listings []ListingWithOrderIndex
|
|
allOrderIndexes []int
|
|
)
|
|
//orderIndexPerListing := make(map[Platform]map[string]int)
|
|
|
|
err := db.beginReadonlyTxn(ctx, func(tx pgx.Tx) error {
|
|
// get the mock sync group editing listings from each table
|
|
|
|
for _, in := range getAllMockShopSchemaInfos() {
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
eli.shop_id,
|
|
eli.listing_id,
|
|
eli.order_index,
|
|
li.name,
|
|
li.count,
|
|
li.sku,
|
|
li.description,
|
|
sh.name as shop_name
|
|
FROM
|
|
%s AS eli
|
|
LEFT JOIN
|
|
%s AS li
|
|
USING
|
|
(account_id, shop_id, listing_id)
|
|
JOIN
|
|
%s AS sh
|
|
USING
|
|
(account_id, shop_id)
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
in.syncGroupEditingListingTable,
|
|
in.listingsTable,
|
|
in.shopTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query to get mock sync group editing listings: %w", err)
|
|
}
|
|
|
|
vs, err := pgx.CollectRows(rows, pgx.RowToStructByNameLax[struct {
|
|
Shop_id string
|
|
Listing_id pgtype.Text
|
|
Order_index int
|
|
Name pgtype.Text
|
|
Count pgtype.Int8
|
|
Sku pgtype.Text
|
|
Description pgtype.Text
|
|
Shop_name string
|
|
}])
|
|
if err != nil {
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
for _, v := range vs {
|
|
listings = append(listings, ListingWithOrderIndex{
|
|
Listing: Listing{
|
|
AccountShopListingIDs: NewAccountIDs(acctID).
|
|
ShopID(in.platform, v.Shop_id).
|
|
ListingID(v.Listing_id.String),
|
|
ShopName: v.Shop_name,
|
|
SKU: v.Sku.String,
|
|
Name: v.Name.String,
|
|
Description: v.Description.String,
|
|
Count: v.Count.Int64,
|
|
},
|
|
OrderIndex: v.Order_index,
|
|
})
|
|
}
|
|
}
|
|
|
|
// loading the empty indexes, too
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
order_index
|
|
FROM
|
|
mock.sync_group_editing_listing_order_indexes
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if allOrderIndexes, err = pgx.CollectRows(rows, pgx.RowTo[int]); err != nil {
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
slices.SortFunc(listings, func(a, b ListingWithOrderIndex) int {
|
|
return a.OrderIndex - b.OrderIndex
|
|
})
|
|
|
|
indexPerOrderIndex := make(map[int]int)
|
|
for i, v := range listings {
|
|
indexPerOrderIndex[v.OrderIndex] = i
|
|
}
|
|
|
|
for _, i := range allOrderIndexes {
|
|
if _, ok := indexPerOrderIndex[i]; ok {
|
|
continue
|
|
}
|
|
|
|
for j := i - 1; j >= 0; j -= 1 {
|
|
index, ok := indexPerOrderIndex[j]
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
// insert the new empty listing into the list
|
|
|
|
listings = slices.Insert(listings, index+1, ListingWithOrderIndex{
|
|
Listing: Listing{
|
|
AccountShopListingIDs: NewAccountIDs(acctID).
|
|
ShopID("", "").
|
|
ListingID(""),
|
|
},
|
|
OrderIndex: i,
|
|
})
|
|
|
|
indexPerOrderIndex[i] = index + 1
|
|
for k, v := range indexPerOrderIndex {
|
|
if k > i {
|
|
indexPerOrderIndex[k] = v + 1
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
return listings, err
|
|
}
|
|
|
|
func (db *Store) MockSyncGroupIsBeingEdited(ctx context.Context, acctID, syncGroupID int64) (bool, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
true
|
|
FROM
|
|
mock.sync_group_editing
|
|
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 false, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if _, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[pgtype.Bool]); err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return false, nil
|
|
}
|
|
return false, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
func (db *Store) GetMockSyncGroupEditingListing(ctx context.Context, acctID, syncGroupID, orderIndex int64) (*Listing, error) {
|
|
var listing *Listing
|
|
|
|
err := db.beginReadonlyTxn(ctx, func(tx pgx.Tx) error {
|
|
// assert the sync group is being edited
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
true
|
|
FROM
|
|
mock.sync_group_editing
|
|
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 fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if _, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[bool]); err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return consts.ErrNotFound
|
|
}
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
// find the editing listing
|
|
|
|
for _, in := range getAllMockShopSchemaInfos() {
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
SELECT
|
|
eli.shop_id,
|
|
eli.listing_id,
|
|
eli.order_index,
|
|
li.name,
|
|
li.count,
|
|
li.sku,
|
|
li.description,
|
|
sh.name as shop_name
|
|
FROM
|
|
%s AS eli
|
|
JOIN
|
|
%s AS li
|
|
USING
|
|
(account_id, shop_id, listing_id)
|
|
JOIN
|
|
%s AS sh
|
|
USING
|
|
(account_id, shop_id)
|
|
WHERE
|
|
account_id = @account_id
|
|
AND eli.order_index = @order_index
|
|
`,
|
|
in.syncGroupEditingListingTable,
|
|
in.listingsTable,
|
|
in.shopTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query to get mock sync group editing listings: %w", err)
|
|
}
|
|
|
|
v, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[struct {
|
|
Shop_id string
|
|
Listing_id string
|
|
Order_index int
|
|
Name string
|
|
Count int64
|
|
Sku string
|
|
Description string
|
|
Shop_name string
|
|
}])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
continue
|
|
}
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
listing = &Listing{
|
|
AccountShopListingIDs: NewAccountIDs(acctID).
|
|
ShopID(in.platform, v.Shop_id).
|
|
ListingID(v.Listing_id),
|
|
ShopName: v.Shop_name,
|
|
SKU: v.Sku,
|
|
Name: v.Name,
|
|
Description: v.Description,
|
|
Count: v.Count,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
return consts.ErrNotFound
|
|
})
|
|
|
|
return listing, err
|
|
}
|
|
|
|
func (db *Store) AddListingToMockSyncGroupBeingEdited(ctx context.Context, acctID int64) (syncGroupID int64, orderIndex int, err error) {
|
|
err = db.beginTxn(ctx, func(tx pgx.Tx) error {
|
|
// assert the sync group is being edited
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
sync_group_id
|
|
FROM
|
|
mock.sync_group_editing
|
|
WHERE
|
|
account_id = @account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
syncGroupID, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int64])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return consts.ErrNotFound
|
|
}
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
rows, err = tx.Query(
|
|
ctx,
|
|
`
|
|
WITH new_order_index AS (
|
|
SELECT
|
|
COALESCE(MAX(order_index)+1, 0) AS order_index
|
|
FROM
|
|
mock.sync_group_editing_listing_order_indexes
|
|
)
|
|
INSERT INTO
|
|
mock.sync_group_editing_listing_order_indexes (
|
|
account_id,
|
|
order_index
|
|
)
|
|
SELECT
|
|
@account_id,
|
|
new_order_index.order_index
|
|
FROM
|
|
new_order_index
|
|
RETURNING
|
|
order_index
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to insert new order index row: %w", err)
|
|
}
|
|
|
|
orderIndex, err = pgx.CollectExactlyOneRow(rows, pgx.RowTo[int])
|
|
if err != nil {
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
return syncGroupID, orderIndex, err
|
|
}
|
|
|
|
func (db *Store) SetShopInListingInMockSyncGroupBeingEdited(ctx context.Context, acctID, syncGroupID int64, orderIndex int, platform Platform, shopID string) error {
|
|
in, ok := getMockShopSchemaInfo(platform)
|
|
if !ok {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
return db.beginTxn(ctx, func(tx pgx.Tx) error {
|
|
// assert the sync group is being edited
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
true
|
|
FROM
|
|
mock.sync_group_editing
|
|
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 fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if _, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[bool]); err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return consts.ErrNotFound
|
|
}
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
// delete old listing: this will delete the store-specific listing row implicitly without the lookup
|
|
|
|
tags, err := tx.Exec(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_editing_listing_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 deleted order index record: %w", err)
|
|
}
|
|
if tags.RowsAffected() == 0 {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
// create new listing
|
|
|
|
_, err = tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
WITH new_order_index_row(account_id, order_index) AS (
|
|
INSERT INTO
|
|
mock.sync_group_editing_listing_order_indexes (
|
|
account_id,
|
|
order_index
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@order_index
|
|
)
|
|
RETURNING
|
|
account_id,
|
|
order_index
|
|
)
|
|
INSERT INTO
|
|
%s AS eli (
|
|
account_id,
|
|
order_index,
|
|
shop_id
|
|
)
|
|
SELECT
|
|
account_id,
|
|
order_index,
|
|
@shop_id as shop_id
|
|
FROM
|
|
new_order_index_row
|
|
`,
|
|
in.syncGroupEditingListingTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query to insert mock sync group editing listings: %w", err)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (db *Store) SetListingInListingInMockSyncGroupBeingEdited(ctx context.Context, acctID, syncGroupID int64, orderIndex int, listingID string) error {
|
|
return db.beginTxn(ctx, func(tx pgx.Tx) error {
|
|
// assert the sync group is being edited
|
|
|
|
rows, err := tx.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
true
|
|
FROM
|
|
mock.sync_group_editing
|
|
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 fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
if _, err := pgx.CollectExactlyOneRow(rows, pgx.RowTo[bool]); err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return consts.ErrNotFound
|
|
}
|
|
return fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
// update the editing listing
|
|
|
|
for _, in := range getAllMockShopSchemaInfos() {
|
|
tag, err := tx.Exec(
|
|
ctx,
|
|
fmt.Sprintf(
|
|
`
|
|
UPDATE
|
|
%s AS eli
|
|
SET
|
|
listing_id = @listing_id
|
|
WHERE
|
|
account_id = @account_id
|
|
AND order_index = @order_index
|
|
`,
|
|
in.syncGroupEditingListingTable,
|
|
),
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"order_index": orderIndex,
|
|
"listing_id": listingID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query to update mock sync group editing listings: %w", err)
|
|
}
|
|
|
|
switch n := tag.RowsAffected(); n {
|
|
case 0:
|
|
continue
|
|
case 1:
|
|
return nil
|
|
default:
|
|
return fmt.Errorf("unexpected number of rows affected: %d", n)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
return consts.ErrNotFound
|
|
})
|
|
}
|
|
|
|
func (db *Store) DeleteListingInListingInMockSyncGroupBeingEdited(ctx context.Context, acctID int64, orderIndex int) error {
|
|
tag, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
DELETE FROM
|
|
mock.sync_group_editing_listing_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() == 0 {
|
|
return consts.ErrNotFound
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// if err := s.accts.SetShopInMockSaleForm(c, acctID, platform, shopID); err != nil {
|
|
|
|
func (db *Store) SetShopInMockSaleForm(ctx context.Context, acctID int64, platform Platform, shopID string) error {
|
|
_, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.sale_form_shop_selection (
|
|
account_id,
|
|
platform,
|
|
shop_id
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@platform,
|
|
@shop_id
|
|
)
|
|
ON CONFLICT (account_id) DO UPDATE
|
|
SET platform = EXCLUDED.platform,
|
|
shop_id = EXCLUDED.shop_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) SetShopInMockRefundForm(ctx context.Context, acctID int64, platform Platform, shopID string) error {
|
|
_, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.refund_form_shop_selection (
|
|
account_id,
|
|
platform,
|
|
shop_id
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@platform,
|
|
@shop_id
|
|
)
|
|
ON CONFLICT (account_id) DO UPDATE
|
|
SET platform = EXCLUDED.platform,
|
|
shop_id = EXCLUDED.shop_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (db *Store) SetShopInMockCountForm(ctx context.Context, acctID int64, platform Platform, shopID string) error {
|
|
_, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.count_form_shop_selection (
|
|
account_id,
|
|
platform,
|
|
shop_id
|
|
)
|
|
VALUES (
|
|
@account_id,
|
|
@platform,
|
|
@shop_id
|
|
)
|
|
ON CONFLICT (account_id) DO UPDATE
|
|
SET platform = EXCLUDED.platform,
|
|
shop_id = EXCLUDED.shop_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type MockEventFormValues struct {
|
|
SaleShopID string
|
|
SalePlatform Platform
|
|
RefundShopID string
|
|
RefundPlatform Platform
|
|
CountShopID string
|
|
CountPlatform Platform
|
|
}
|
|
|
|
func (db *Store) GetMockEventFormValues(ctx context.Context, acctID int64) (*MockEventFormValues, error) {
|
|
rows, err := db.db.Query(
|
|
ctx,
|
|
`
|
|
SELECT
|
|
sf.platform AS sale_platform,
|
|
sf.shop_id AS sale_shop_id,
|
|
rf.platform AS refund_platform,
|
|
rf.shop_id AS refund_shop_id,
|
|
cf.platform AS count_platform,
|
|
cf.shop_id AS count_shop_id
|
|
FROM
|
|
mock.sale_form_shop_selection AS sf
|
|
FULL OUTER JOIN
|
|
mock.refund_form_shop_selection AS rf
|
|
USING
|
|
(account_id)
|
|
FULL OUTER JOIN
|
|
mock.count_form_shop_selection AS cf
|
|
USING
|
|
(account_id)
|
|
WHERE
|
|
sf.account_id = @account_id
|
|
`,
|
|
pgx.NamedArgs{
|
|
"account_id": acctID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
v, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByNameLax[struct {
|
|
Sale_shop_id pgtype.Text
|
|
Sale_platform *Platform
|
|
Refund_shop_id pgtype.Text
|
|
Refund_platform *Platform
|
|
Count_shop_id pgtype.Text
|
|
Count_platform *Platform
|
|
}])
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return &MockEventFormValues{}, nil
|
|
}
|
|
return nil, fmt.Errorf("failed to scan rows: %w", err)
|
|
}
|
|
|
|
return &MockEventFormValues{
|
|
SaleShopID: v.Sale_shop_id.String,
|
|
SalePlatform: deref(v.Sale_platform),
|
|
RefundShopID: v.Refund_shop_id.String,
|
|
RefundPlatform: deref(v.Refund_platform),
|
|
CountShopID: v.Count_shop_id.String,
|
|
CountPlatform: deref(v.Count_platform),
|
|
}, nil
|
|
}
|
|
|
|
func (db *Store) SaveNewMockSale(ctx context.Context, acctID int64, platform Platform, shopID, listingID string, count int) (uuid.UUID, error) {
|
|
eventID := uuid.New()
|
|
|
|
_, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.raw_shop_events (
|
|
platform,
|
|
shop_id,
|
|
event_timestamp,
|
|
event_id,
|
|
raw_payload
|
|
)
|
|
VALUES (
|
|
@platform,
|
|
@shop_id,
|
|
NOW(),
|
|
@event_id,
|
|
@raw_payload
|
|
)
|
|
`,
|
|
pgx.NamedArgs{
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
"event_id": eventID,
|
|
"raw_payload": json.RawMessage(fmt.Sprintf(`{
|
|
"type": "sale",
|
|
"listingID": %q,
|
|
"count": %d
|
|
}`, listingID, count)),
|
|
},
|
|
)
|
|
if err != nil {
|
|
return uuid.Nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
return eventID, nil
|
|
}
|
|
|
|
func (db *Store) SaveNewMockRefund(ctx context.Context, acctID int64, platform Platform, shopID, listingID string, count int) (uuid.UUID, error) {
|
|
eventID := uuid.New()
|
|
|
|
_, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.raw_shop_events (
|
|
platform,
|
|
shop_id,
|
|
event_timestamp,
|
|
event_id,
|
|
raw_payload
|
|
)
|
|
VALUES (
|
|
@platform,
|
|
@shop_id,
|
|
NOW(),
|
|
@event_id,
|
|
@raw_payload
|
|
)
|
|
`,
|
|
pgx.NamedArgs{
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
"event_id": eventID,
|
|
"raw_payload": json.RawMessage(fmt.Sprintf(`{
|
|
"type": "refund",
|
|
"listingID": %q,
|
|
"count": %d
|
|
}`, listingID, count)),
|
|
},
|
|
)
|
|
if err != nil {
|
|
return uuid.Nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
return eventID, nil
|
|
}
|
|
|
|
func (db *Store) SaveNewMockInventoryReset(ctx context.Context, acctID int64, platform Platform, shopID, listingID string, count int) (uuid.UUID, error) {
|
|
eventID := uuid.New()
|
|
|
|
_, err := db.db.Exec(
|
|
ctx,
|
|
`
|
|
INSERT INTO
|
|
mock.raw_shop_events (
|
|
platform,
|
|
shop_id,
|
|
event_timestamp,
|
|
event_id,
|
|
raw_payload
|
|
)
|
|
VALUES (
|
|
@platform,
|
|
@shop_id,
|
|
NOW(),
|
|
@event_id,
|
|
@raw_payload
|
|
)
|
|
`,
|
|
pgx.NamedArgs{
|
|
"platform": platform,
|
|
"shop_id": shopID,
|
|
"event_id": eventID,
|
|
"raw_payload": json.RawMessage(fmt.Sprintf(`{
|
|
"type": "inventory-reset",
|
|
"listingID": %q,
|
|
"count": %d
|
|
}`, listingID, count)),
|
|
},
|
|
)
|
|
if err != nil {
|
|
return uuid.Nil, fmt.Errorf("failed to perform query: %w", err)
|
|
}
|
|
|
|
return eventID, nil
|
|
}
|
|
|
|
// additional context
|
|
|
|
func (db *Store) GetAccountPointerByUserID(ctx context.Context, userID string) (*Account, error) {
|
|
acct, err := db.GetAccountByUserID(ctx, userID)
|
|
if err == nil {
|
|
return &acct, nil
|
|
}
|
|
if errors.Is(err, consts.ErrNotFound) {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
func (db *Store) beginReadonlyTxn(ctx context.Context, cb func(pgx.Tx) error) error {
|
|
return pgx.BeginTxFunc(ctx, db.db, pgx.TxOptions{AccessMode: pgx.ReadOnly}, cb)
|
|
}
|
|
|
|
func (db *Store) beginTxn(ctx context.Context, cb func(pgx.Tx) error) error {
|
|
return pgx.BeginFunc(ctx, db.db, cb)
|
|
}
|
|
|
|
func deref[T any](ptr *T) T {
|
|
if ptr != nil {
|
|
return *ptr
|
|
}
|
|
var zero T
|
|
return zero
|
|
}
|