From cd43a6f23ad38efdb4ac0043b74f1ea7a4910dbf Mon Sep 17 00:00:00 2001 From: itsscb Date: Wed, 20 Sep 2023 21:40:32 +0200 Subject: [PATCH] Itsscb/issue_ftadd-returnsLog-2 (#14) --- db/migration/000001_init_schema.up.sql | 4 +- db/query/returnsLog.sql | 39 ++++++ db/sqlc/customer_test.go | 9 +- db/sqlc/document_test.go | 6 +- db/sqlc/mail_test.go | 6 +- db/sqlc/models.go | 16 +-- db/sqlc/payment_test.go | 5 +- db/sqlc/person_test.go | 5 +- db/sqlc/provider_test.go | 6 +- db/sqlc/return_test.go | 5 +- db/sqlc/returnsLog.sql.go | 174 +++++++++++++++++++++++++ db/sqlc/returnsLog_test.go | 122 +++++++++++++++++ 12 files changed, 378 insertions(+), 19 deletions(-) create mode 100644 db/query/returnsLog.sql create mode 100644 db/sqlc/returnsLog.sql.go create mode 100644 db/sqlc/returnsLog_test.go diff --git a/db/migration/000001_init_schema.up.sql b/db/migration/000001_init_schema.up.sql index 7b14282..e693fd8 100644 --- a/db/migration/000001_init_schema.up.sql +++ b/db/migration/000001_init_schema.up.sql @@ -115,7 +115,7 @@ CREATE TABLE "returns" ( CREATE TABLE "returnsLog" ( "ID" bigserial UNIQUE PRIMARY KEY NOT NULL, - "returnsID" bigint NOT NULL, + "returnID" bigint NOT NULL, "mailID" bigint NOT NULL, "status" varchar, "creator" varchar NOT NULL, @@ -136,6 +136,6 @@ ALTER TABLE "returns" ADD FOREIGN KEY ("personID") REFERENCES "persons" ("ID"); ALTER TABLE "returns" ADD FOREIGN KEY ("providerID") REFERENCES "providers" ("ID"); -ALTER TABLE "returnsLog" ADD FOREIGN KEY ("returnsID") REFERENCES "returns" ("ID"); +ALTER TABLE "returnsLog" ADD FOREIGN KEY ("returnID") REFERENCES "returns" ("ID"); ALTER TABLE "returnsLog" ADD FOREIGN KEY ("mailID") REFERENCES "mails" ("ID"); \ No newline at end of file diff --git a/db/query/returnsLog.sql b/db/query/returnsLog.sql new file mode 100644 index 0000000..11a954f --- /dev/null +++ b/db/query/returnsLog.sql @@ -0,0 +1,39 @@ +-- name: GetReturnsLog :one +SELECT * FROM "returnsLog" +WHERE "ID" = sqlc.arg(ID) LIMIT 1; + +-- name: CreateReturnsLog :one +INSERT INTO "returnsLog" ( + "returnID", + "mailID", + "status", + "creator", + "changer" +) VALUES ( + sqlc.arg(returnID), + sqlc.arg(mailID), + sqlc.arg(status), + sqlc.arg(creator), + sqlc.arg(creator) +) RETURNING *; + +-- name: ListReturnsLogs :many +SELECT * FROM "returnsLog" +ORDER BY status +LIMIT $1 +OFFSET $2; + +-- name: UpdateReturnsLog :one +UPDATE "returnsLog" +SET + "returnID" = COALESCE(sqlc.narg(returnID), "returnID"), + "mailID" = COALESCE(sqlc.narg(mailID), "mailID"), + "status" = COALESCE(sqlc.narg(status), "status"), + changer = $1, + changed = now() +WHERE "ID" = sqlc.arg(ID) +RETURNING *; + +-- name: DeleteReturnsLog :exec +DELETE FROM "returnsLog" +WHERE "ID" = sqlc.arg(ID); \ No newline at end of file diff --git a/db/sqlc/customer_test.go b/db/sqlc/customer_test.go index f1c82d8..7d7018b 100644 --- a/db/sqlc/customer_test.go +++ b/db/sqlc/customer_test.go @@ -11,6 +11,9 @@ import ( ) func createRandomCustomer(t *testing.T) Customer { + + creator := util.RandomUser() + arg := CreateCustomerParams{ Username: util.RandomUser(), Passwordhash: util.RandomString(30), @@ -26,7 +29,8 @@ func createRandomCustomer(t *testing.T) Customer { Zip: util.RandomString(5), Street: util.RandomString(20), Country: util.RandomString(15), - Creator: util.RandomUser(), + Creator: creator, + Changer: creator, } account, err := testQueries.CreateCustomer(context.Background(), arg) @@ -45,6 +49,7 @@ func createRandomCustomer(t *testing.T) Customer { require.Equal(t, arg.Street, account.Street) require.Equal(t, arg.Country, account.Country) require.Equal(t, arg.Creator, account.Creator) + require.Equal(t, arg.Changer, account.Changer) require.NotZero(t, account.ID) require.NotZero(t, account.Created) @@ -76,6 +81,7 @@ func TestGetCustomer(t *testing.T) { require.Equal(t, newAccount.Street, account.Street) require.Equal(t, newAccount.Country, account.Country) require.Equal(t, newAccount.Creator, account.Creator) + require.Equal(t, newAccount.Changer, account.Changer) require.WithinDuration(t, newAccount.Created, account.Created, time.Second) } @@ -110,6 +116,7 @@ func TestUpdateCustomer(t *testing.T) { require.Equal(t, account1.ID, account2.ID) require.Equal(t, account1.Username, account2.Username) require.NotEqual(t, account1.Phone, account2.Phone) + require.NotEqual(t, account1.Changer, account2.Changer) } func TestListCustomers(t *testing.T) { diff --git a/db/sqlc/document_test.go b/db/sqlc/document_test.go index 7519c15..f9eada2 100644 --- a/db/sqlc/document_test.go +++ b/db/sqlc/document_test.go @@ -14,6 +14,8 @@ func createRandomDocumentUpload(t *testing.T) Document { person := createRandomPerson(t) require.NotEmpty(t, person) + creator := util.RandomUser() + arg := CreateDocumentUploadParams{ PersonID: sql.NullInt64{ Valid: true, @@ -23,8 +25,8 @@ func createRandomDocumentUpload(t *testing.T) Document { Type: util.RandomUser(), Path: util.RandomString(50), Url: util.RandomString(60), - Creator: util.RandomUser(), - Changer: util.RandomUser(), + Creator: creator, + Changer: creator, } document, err := testQueries.CreateDocumentUpload(context.Background(), arg) diff --git a/db/sqlc/mail_test.go b/db/sqlc/mail_test.go index e27322a..bd059da 100644 --- a/db/sqlc/mail_test.go +++ b/db/sqlc/mail_test.go @@ -12,6 +12,8 @@ import ( func createRandomMail(t *testing.T) Mail { + creator := util.RandomUser() + arg := CreateMailParams{ From: util.RandomEmail(), To: []string{util.RandomEmail()}, @@ -19,8 +21,8 @@ func createRandomMail(t *testing.T) Mail { Subject: util.RandomString(20), Body: util.RandomString(300), Timestamp: time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC), - Creator: util.RandomUser(), - Changer: util.RandomUser(), + Creator: creator, + Changer: creator, } mail, err := testQueries.CreateMail(context.Background(), arg) diff --git a/db/sqlc/models.go b/db/sqlc/models.go index 042f35a..f7660b3 100644 --- a/db/sqlc/models.go +++ b/db/sqlc/models.go @@ -125,12 +125,12 @@ type Return struct { } type ReturnsLog struct { - ID int64 `json:"ID"` - ReturnsID int64 `json:"returnsID"` - MailID int64 `json:"mailID"` - Status sql.NullString `json:"status"` - Creator string `json:"creator"` - Created time.Time `json:"created"` - Changer string `json:"changer"` - Changed time.Time `json:"changed"` + ID int64 `json:"ID"` + ReturnID int64 `json:"returnID"` + MailID int64 `json:"mailID"` + Status sql.NullString `json:"status"` + Creator string `json:"creator"` + Created time.Time `json:"created"` + Changer string `json:"changer"` + Changed time.Time `json:"changed"` } diff --git a/db/sqlc/payment_test.go b/db/sqlc/payment_test.go index fcaee68..c55135d 100644 --- a/db/sqlc/payment_test.go +++ b/db/sqlc/payment_test.go @@ -14,6 +14,8 @@ func createRandomPayment(t *testing.T) Payment { account := createRandomCustomer(t) require.NotEmpty(t, account) + creator := util.RandomUser() + arg := CreatePaymentParams{ CustomerID: account.ID, PaymentCategory: util.RandomUser(), @@ -42,7 +44,8 @@ func createRandomPayment(t *testing.T) Payment { String: util.RandomUser(), }, Type: util.RandomUser(), - Creator: util.RandomUser(), + Creator: creator, + Changer: creator, } person, err := testQueries.CreatePayment(context.Background(), arg) diff --git a/db/sqlc/person_test.go b/db/sqlc/person_test.go index ab2b5f7..17d3d47 100644 --- a/db/sqlc/person_test.go +++ b/db/sqlc/person_test.go @@ -14,6 +14,8 @@ func createRandomPerson(t *testing.T) Person { account := createRandomCustomer(t) require.NotEmpty(t, account) + creator := util.RandomUser() + arg := CreatePersonParams{ CustomerID: account.ID, Firstname: util.RandomUser(), @@ -23,7 +25,8 @@ func createRandomPerson(t *testing.T) Person { Zip: util.RandomString(5), Street: util.RandomString(20), Country: util.RandomString(15), - Creator: util.RandomUser(), + Creator: creator, + Changer: creator, } person, err := testQueries.CreatePerson(context.Background(), arg) diff --git a/db/sqlc/provider_test.go b/db/sqlc/provider_test.go index 5fa6316..01b9280 100644 --- a/db/sqlc/provider_test.go +++ b/db/sqlc/provider_test.go @@ -11,12 +11,16 @@ import ( ) func createRandomProvider(t *testing.T) Provider { + + creator := util.RandomUser() + arg := CreateProviderParams{ Name: util.RandomUser(), Description: util.RandomString(30), Category: util.RandomUser(), Email: util.RandomUser(), - Creator: util.RandomUser(), + Creator: creator, + Changer: creator, } provider, err := testQueries.CreateProvider(context.Background(), arg) diff --git a/db/sqlc/return_test.go b/db/sqlc/return_test.go index d09a67f..391724d 100644 --- a/db/sqlc/return_test.go +++ b/db/sqlc/return_test.go @@ -15,6 +15,8 @@ func createRandomReturn(t *testing.T) Return { person := createRandomPerson(t) provider := createRandomProvider(t) + creator := util.RandomUser() + arg := CreateReturnParams{ Personid: person.ID, Providerid: provider.ID, @@ -23,7 +25,8 @@ func createRandomReturn(t *testing.T) Return { Description: util.RandomString(30), Category: util.RandomUser(), Email: util.RandomUser(), - Creator: util.RandomUser(), + Creator: creator, + Changer: creator, } ret, err := testQueries.CreateReturn(context.Background(), arg) diff --git a/db/sqlc/returnsLog.sql.go b/db/sqlc/returnsLog.sql.go new file mode 100644 index 0000000..a4bb37a --- /dev/null +++ b/db/sqlc/returnsLog.sql.go @@ -0,0 +1,174 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.21.0 +// source: returnsLog.sql + +package db + +import ( + "context" + "database/sql" +) + +const createReturnsLog = `-- name: CreateReturnsLog :one +INSERT INTO "returnsLog" ( + "returnID", + "mailID", + "status", + "creator", + "changer" +) VALUES ( + $1, + $2, + $3, + $4, + $5 +) RETURNING "ID", "returnID", "mailID", status, creator, created, changer, changed +` + +type CreateReturnsLogParams struct { + Returnid int64 `json:"returnid"` + Mailid int64 `json:"mailid"` + Status sql.NullString `json:"status"` + Creator string `json:"creator"` + Changer string `json:"changer"` +} + +func (q *Queries) CreateReturnsLog(ctx context.Context, arg CreateReturnsLogParams) (ReturnsLog, error) { + row := q.db.QueryRowContext(ctx, createReturnsLog, + arg.Returnid, + arg.Mailid, + arg.Status, + arg.Creator, + arg.Changer, + ) + var i ReturnsLog + err := row.Scan( + &i.ID, + &i.ReturnID, + &i.MailID, + &i.Status, + &i.Creator, + &i.Created, + &i.Changer, + &i.Changed, + ) + return i, err +} + +const deleteReturnsLog = `-- name: DeleteReturnsLog :exec +DELETE FROM "returnsLog" +WHERE "ID" = $1 +` + +func (q *Queries) DeleteReturnsLog(ctx context.Context, id int64) error { + _, err := q.db.ExecContext(ctx, deleteReturnsLog, id) + return err +} + +const getReturnsLog = `-- name: GetReturnsLog :one +SELECT "ID", "returnID", "mailID", status, creator, created, changer, changed FROM "returnsLog" +WHERE "ID" = $1 LIMIT 1 +` + +func (q *Queries) GetReturnsLog(ctx context.Context, id int64) (ReturnsLog, error) { + row := q.db.QueryRowContext(ctx, getReturnsLog, id) + var i ReturnsLog + err := row.Scan( + &i.ID, + &i.ReturnID, + &i.MailID, + &i.Status, + &i.Creator, + &i.Created, + &i.Changer, + &i.Changed, + ) + return i, err +} + +const listReturnsLogs = `-- name: ListReturnsLogs :many +SELECT "ID", "returnID", "mailID", status, creator, created, changer, changed FROM "returnsLog" +ORDER BY status +LIMIT $1 +OFFSET $2 +` + +type ListReturnsLogsParams struct { + Limit int32 `json:"limit"` + Offset int32 `json:"offset"` +} + +func (q *Queries) ListReturnsLogs(ctx context.Context, arg ListReturnsLogsParams) ([]ReturnsLog, error) { + rows, err := q.db.QueryContext(ctx, listReturnsLogs, arg.Limit, arg.Offset) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ReturnsLog{} + for rows.Next() { + var i ReturnsLog + if err := rows.Scan( + &i.ID, + &i.ReturnID, + &i.MailID, + &i.Status, + &i.Creator, + &i.Created, + &i.Changer, + &i.Changed, + ); 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 updateReturnsLog = `-- name: UpdateReturnsLog :one +UPDATE "returnsLog" +SET + "returnID" = COALESCE($2, "returnID"), + "mailID" = COALESCE($3, "mailID"), + "status" = COALESCE($4, "status"), + changer = $1, + changed = now() +WHERE "ID" = $5 +RETURNING "ID", "returnID", "mailID", status, creator, created, changer, changed +` + +type UpdateReturnsLogParams struct { + Changer string `json:"changer"` + Returnid sql.NullInt64 `json:"returnid"` + Mailid sql.NullInt64 `json:"mailid"` + Status sql.NullString `json:"status"` + ID int64 `json:"id"` +} + +func (q *Queries) UpdateReturnsLog(ctx context.Context, arg UpdateReturnsLogParams) (ReturnsLog, error) { + row := q.db.QueryRowContext(ctx, updateReturnsLog, + arg.Changer, + arg.Returnid, + arg.Mailid, + arg.Status, + arg.ID, + ) + var i ReturnsLog + err := row.Scan( + &i.ID, + &i.ReturnID, + &i.MailID, + &i.Status, + &i.Creator, + &i.Created, + &i.Changer, + &i.Changed, + ) + return i, err +} diff --git a/db/sqlc/returnsLog_test.go b/db/sqlc/returnsLog_test.go new file mode 100644 index 0000000..ef9494b --- /dev/null +++ b/db/sqlc/returnsLog_test.go @@ -0,0 +1,122 @@ +package db + +import ( + "context" + "database/sql" + "testing" + "time" + + "github.com/itsscb/df/util" + "github.com/stretchr/testify/require" +) + +func createRandomReturnsLog(t *testing.T) ReturnsLog { + + ret := createRandomReturn(t) + mail := createRandomMail(t) + + creator := util.RandomUser() + + arg := CreateReturnsLogParams{ + Returnid: ret.ID, + Mailid: mail.ID, + Status: sql.NullString{ + Valid: true, + String: util.RandomString(7), + }, + Creator: creator, + Changer: creator, + } + + returnsLog, err := testQueries.CreateReturnsLog(context.Background(), arg) + require.NoError(t, err) + require.NotEmpty(t, returnsLog) + + require.Equal(t, arg.Returnid, returnsLog.ReturnID) + require.Equal(t, arg.Mailid, returnsLog.MailID) + require.Equal(t, arg.Status, returnsLog.Status) + require.Equal(t, arg.Creator, returnsLog.Creator) + + require.NotZero(t, returnsLog.ID) + require.NotZero(t, returnsLog.Created) + + return returnsLog +} + +func TestCreateReturnsLog(t *testing.T) { + createRandomReturnsLog(t) +} + +func TestGetReturnsLog(t *testing.T) { + newReturnsLog := createRandomReturnsLog(t) + require.NotEmpty(t, newReturnsLog) + + returnsLog, err := testQueries.GetReturnsLog(context.Background(), newReturnsLog.ID) + require.NoError(t, err) + require.NotEmpty(t, returnsLog) + + require.Equal(t, newReturnsLog.ReturnID, returnsLog.ReturnID) + require.Equal(t, newReturnsLog.MailID, returnsLog.MailID) + require.Equal(t, newReturnsLog.Status, returnsLog.Status) + require.Equal(t, newReturnsLog.Created, returnsLog.Created) + require.Equal(t, newReturnsLog.Changer, returnsLog.Changer) + require.Equal(t, newReturnsLog.Changed, returnsLog.Changed) + require.Equal(t, newReturnsLog.Creator, returnsLog.Creator) + + require.WithinDuration(t, newReturnsLog.Created, returnsLog.Created, time.Second) +} + +func TestDeleteReturnsLog(t *testing.T) { + returnsLog1 := createRandomReturnsLog(t) + err := testQueries.DeleteReturnsLog(context.Background(), returnsLog1.ID) + require.NoError(t, err) + + returnsLog2, err := testQueries.GetReturnsLog(context.Background(), returnsLog1.ID) + require.Error(t, err) + require.EqualError(t, err, sql.ErrNoRows.Error()) + require.Empty(t, returnsLog2) +} + +func TestUpdateReturnsLog(t *testing.T) { + returnsLog1 := createRandomReturnsLog(t) + require.NotEmpty(t, returnsLog1) + + status := util.RandomString(15) + + arg := UpdateReturnsLogParams{ + ID: returnsLog1.ID, + Status: sql.NullString{ + String: status, + Valid: true, + }, + } + + returnsLog2, err := testQueries.UpdateReturnsLog(context.Background(), arg) + require.NoError(t, err) + require.NotEmpty(t, returnsLog2) + + require.Equal(t, returnsLog1.ID, returnsLog2.ID) + require.Equal(t, returnsLog2.ReturnID, returnsLog1.ReturnID) + require.NotEqual(t, returnsLog1.Status, returnsLog2.Status) + require.NotEqual(t, returnsLog1.Changed, returnsLog2.Changed) + require.NotEqual(t, returnsLog1.Changer, returnsLog2.Changer) +} + +func TestListReturnsLogs(t *testing.T) { + for i := 0; i < 10; i++ { + createRandomReturnsLog(t) + } + + arg := ListReturnsLogsParams{ + Limit: 5, + Offset: 5, + } + + returnsLogs, err := testQueries.ListReturnsLogs(context.Background(), arg) + require.NoError(t, err) + require.Len(t, returnsLogs, 5) + + for _, returnsLog := range returnsLogs { + require.NotEmpty(t, returnsLog) + } +}