118 lines
3.9 KiB
Go
118 lines
3.9 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
)
|
|
|
|
type Account struct {
|
|
ID int64
|
|
TaskID int64
|
|
SrcLogin string
|
|
SrcPassEnc string
|
|
DstLogin string
|
|
DstPassEnc string
|
|
TestSrcStatus string
|
|
TestDstStatus string
|
|
Status string
|
|
Copied int64
|
|
Skipped int64
|
|
Errors int64
|
|
LastError string
|
|
FolderMapping map[string]string
|
|
ExcludedFolders []string
|
|
}
|
|
|
|
func (s *Store) CreateAccount(ctx context.Context, a Account) (int64, error) {
|
|
var id int64
|
|
err := s.Pool.QueryRow(ctx,
|
|
`INSERT INTO accounts (task_id, src_login, src_pass_enc, dst_login, dst_pass_enc)
|
|
VALUES ($1,$2,$3,$4,$5) RETURNING id`,
|
|
a.TaskID, a.SrcLogin, a.SrcPassEnc, a.DstLogin, a.DstPassEnc).Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
// DeleteAccount removes one account (and its migrated_messages via ON DELETE CASCADE).
|
|
func (s *Store) DeleteAccount(ctx context.Context, id int64) error {
|
|
_, err := s.Pool.Exec(ctx, `DELETE FROM accounts WHERE id=$1`, id)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) ListAccountsByTask(ctx context.Context, taskID int64) ([]Account, error) {
|
|
rows, err := s.Pool.Query(ctx,
|
|
`SELECT id, task_id, src_login, src_pass_enc, dst_login, dst_pass_enc,
|
|
test_src_status, test_dst_status, status, copied_count, skipped_count,
|
|
error_count, last_error, folder_mapping, excluded_folders
|
|
FROM accounts WHERE task_id=$1 ORDER BY id`, taskID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := []Account{}
|
|
for rows.Next() {
|
|
var a Account
|
|
if err := rows.Scan(&a.ID, &a.TaskID, &a.SrcLogin, &a.SrcPassEnc, &a.DstLogin, &a.DstPassEnc,
|
|
&a.TestSrcStatus, &a.TestDstStatus, &a.Status, &a.Copied, &a.Skipped, &a.Errors, &a.LastError,
|
|
&a.FolderMapping, &a.ExcludedFolders); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, a)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// SetAccountError stores (or clears, with "") the last error message shown for
|
|
// an account, so it survives a page reload after the run's live log is gone.
|
|
func (s *Store) SetAccountError(ctx context.Context, id int64, msg string) error {
|
|
_, err := s.Pool.Exec(ctx, `UPDATE accounts SET last_error=$2 WHERE id=$1`, id, msg)
|
|
return err
|
|
}
|
|
|
|
// side = "src" | "dst"
|
|
func (s *Store) SetAccountTestStatus(ctx context.Context, id int64, side, status string) error {
|
|
col := "test_src_status"
|
|
if side == "dst" {
|
|
col = "test_dst_status"
|
|
}
|
|
_, err := s.Pool.Exec(ctx, fmt.Sprintf(`UPDATE accounts SET %s=$2 WHERE id=$1`, col), id, status)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) SetAccountStatus(ctx context.Context, id int64, status string) error {
|
|
_, err := s.Pool.Exec(ctx, `UPDATE accounts SET status=$2 WHERE id=$1`, id, status)
|
|
return err
|
|
}
|
|
|
|
// ResetAccountCounters zeroes the per-account copied/skipped/error counts at the
|
|
// start of a run so a re-run reflects only the current run's totals instead of
|
|
// accumulating on top of the previous run (IncAccountCounters is additive).
|
|
func (s *Store) ResetAccountCounters(ctx context.Context, id int64) error {
|
|
_, err := s.Pool.Exec(ctx,
|
|
`UPDATE accounts SET copied_count=0, skipped_count=0, error_count=0 WHERE id=$1`, id)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) IncAccountCounters(ctx context.Context, id, copied, skipped, errs int64) error {
|
|
_, err := s.Pool.Exec(ctx,
|
|
`UPDATE accounts SET copied_count=copied_count+$2,
|
|
skipped_count=skipped_count+$3, error_count=error_count+$4 WHERE id=$1`,
|
|
id, copied, skipped, errs)
|
|
return err
|
|
}
|
|
|
|
// SetAccountFolderMapping persists an account's per-folder rename map and the
|
|
// set of source folders to skip. nil is normalized to empty so JSONB stays
|
|
// '{}' / '[]' rather than null.
|
|
func (s *Store) SetAccountFolderMapping(ctx context.Context, id int64, mapping map[string]string, excluded []string) error {
|
|
if mapping == nil {
|
|
mapping = map[string]string{}
|
|
}
|
|
if excluded == nil {
|
|
excluded = []string{}
|
|
}
|
|
_, err := s.Pool.Exec(ctx,
|
|
`UPDATE accounts SET folder_mapping=$2, excluded_folders=$3 WHERE id=$1`,
|
|
id, mapping, excluded)
|
|
return err
|
|
}
|