gisle/stufflog3
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add remaining scope repo methods.

Browse Source
This commit is contained in:
gisle
2022-04-16 19:24:56 +02:00
parent 11c0bd62e2
commit 5ec3d938ab
5 changed files with 278 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/scope.go
+2 -2
View File
@@ -8,11 +8,11 @@ import (
)
func Scopes(g *gin.RouterGroup, db database.Database) {
g.GET("/", handler("goals", func(c *gin.Context) (interface{}, error) {
g.GET("/", handler("scopes", func(c *gin.Context) (interface{}, error) {
return db.Scopes().ListByUser(c.Request.Context(), auth.UserID(c))
}))
g.GET("/:id", handler("goals", func(c *gin.Context) (interface{}, error) {
g.GET("/:id", handler("scope", func(c *gin.Context) (interface{}, error) {
id, err := reqInt(c, "id")
if err != nil {
return nil, err
internal/database/mysql/mysqlcore/db.go
+60
View File
@@ -24,6 +24,15 @@ func New(db DBTX) *Queries {
func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
q := Queries{db: db}
var err error
if q.deleteAllScopeMembersStmt, err = db.PrepareContext(ctx, deleteAllScopeMembers); err != nil {
return nil, fmt.Errorf("error preparing query DeleteAllScopeMembers: %w", err)
}
if q.deleteScopeStmt, err = db.PrepareContext(ctx, deleteScope); err != nil {
return nil, fmt.Errorf("error preparing query DeleteScope: %w", err)
}
if q.deleteScopeMemberStmt, err = db.PrepareContext(ctx, deleteScopeMember); err != nil {
return nil, fmt.Errorf("error preparing query DeleteScopeMember: %w", err)
}
if q.getScopeStmt, err = db.PrepareContext(ctx, getScope); err != nil {
return nil, fmt.Errorf("error preparing query GetScope: %w", err)
}
@@ -33,6 +42,9 @@ func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
if q.getScopeWithDisplayNameStmt, err = db.PrepareContext(ctx, getScopeWithDisplayName); err != nil {
return nil, fmt.Errorf("error preparing query GetScopeWithDisplayName: %w", err)
}
if q.insertScopeStmt, err = db.PrepareContext(ctx, insertScope); err != nil {
return nil, fmt.Errorf("error preparing query InsertScope: %w", err)
}
if q.listProjectEntriesStmt, err = db.PrepareContext(ctx, listProjectEntries); err != nil {
return nil, fmt.Errorf("error preparing query ListProjectEntries: %w", err)
}
@@ -48,11 +60,32 @@ func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
if q.listStatsStmt, err = db.PrepareContext(ctx, listStats); err != nil {
return nil, fmt.Errorf("error preparing query ListStats: %w", err)
}
if q.updateScopeStmt, err = db.PrepareContext(ctx, updateScope); err != nil {
return nil, fmt.Errorf("error preparing query UpdateScope: %w", err)
}
if q.updateScopeMemberStmt, err = db.PrepareContext(ctx, updateScopeMember); err != nil {
return nil, fmt.Errorf("error preparing query UpdateScopeMember: %w", err)
}
return &q, nil
}
func (q *Queries) Close() error {
var err error
if q.deleteAllScopeMembersStmt != nil {
if cerr := q.deleteAllScopeMembersStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing deleteAllScopeMembersStmt: %w", cerr)
}
}
if q.deleteScopeStmt != nil {
if cerr := q.deleteScopeStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing deleteScopeStmt: %w", cerr)
}
}
if q.deleteScopeMemberStmt != nil {
if cerr := q.deleteScopeMemberStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing deleteScopeMemberStmt: %w", cerr)
}
}
if q.getScopeStmt != nil {
if cerr := q.getScopeStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing getScopeStmt: %w", cerr)
@@ -68,6 +101,11 @@ func (q *Queries) Close() error {
err = fmt.Errorf("error closing getScopeWithDisplayNameStmt: %w", cerr)
}
}
if q.insertScopeStmt != nil {
if cerr := q.insertScopeStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing insertScopeStmt: %w", cerr)
}
}
if q.listProjectEntriesStmt != nil {
if cerr := q.listProjectEntriesStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing listProjectEntriesStmt: %w", cerr)
@@ -93,6 +131,16 @@ func (q *Queries) Close() error {
err = fmt.Errorf("error closing listStatsStmt: %w", cerr)
}
}
if q.updateScopeStmt != nil {
if cerr := q.updateScopeStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing updateScopeStmt: %w", cerr)
}
}
if q.updateScopeMemberStmt != nil {
if cerr := q.updateScopeMemberStmt.Close(); cerr != nil {
err = fmt.Errorf("error closing updateScopeMemberStmt: %w", cerr)
}
}
return err
}
@@ -132,27 +180,39 @@ func (q *Queries) queryRow(ctx context.Context, stmt *sql.Stmt, query string, ar
type Queries struct {
db DBTX
tx *sql.Tx
deleteAllScopeMembersStmt *sql.Stmt
deleteScopeStmt *sql.Stmt
deleteScopeMemberStmt *sql.Stmt
getScopeStmt *sql.Stmt
getScopeDisplayNameStmt *sql.Stmt
getScopeWithDisplayNameStmt *sql.Stmt
insertScopeStmt *sql.Stmt
listProjectEntriesStmt *sql.Stmt
listScopeMembersStmt *sql.Stmt
listScopesStmt *sql.Stmt
listScopesByUserStmt *sql.Stmt
listStatsStmt *sql.Stmt
updateScopeStmt *sql.Stmt
updateScopeMemberStmt *sql.Stmt
}
func (q *Queries) WithTx(tx *sql.Tx) *Queries {
return &Queries{
db: tx,
tx: tx,
deleteAllScopeMembersStmt: q.deleteAllScopeMembersStmt,
deleteScopeStmt: q.deleteScopeStmt,
deleteScopeMemberStmt: q.deleteScopeMemberStmt,
getScopeStmt: q.getScopeStmt,
getScopeDisplayNameStmt: q.getScopeDisplayNameStmt,
getScopeWithDisplayNameStmt: q.getScopeWithDisplayNameStmt,
insertScopeStmt: q.insertScopeStmt,
listProjectEntriesStmt: q.listProjectEntriesStmt,
listScopeMembersStmt: q.listScopeMembersStmt,
listScopesStmt: q.listScopesStmt,
listScopesByUserStmt: q.listScopesByUserStmt,
listStatsStmt: q.listStatsStmt,
updateScopeStmt: q.updateScopeStmt,
updateScopeMemberStmt: q.updateScopeMemberStmt,
}
}
internal/database/mysql/mysqlcore/scope.sql.go
+84
View File
@@ -10,6 +10,38 @@ import (
"database/sql"
)
const deleteAllScopeMembers = `-- name: DeleteAllScopeMembers :exec
DELETE FROM scope_member WHERE scope_id=?
`
func (q *Queries) DeleteAllScopeMembers(ctx context.Context, scopeID int) error {
_, err := q.exec(ctx, q.deleteAllScopeMembersStmt, deleteAllScopeMembers, scopeID)
return err
}
const deleteScope = `-- name: DeleteScope :exec
DELETE FROM scope WHERE id=?
`
func (q *Queries) DeleteScope(ctx context.Context, id int) error {
_, err := q.exec(ctx, q.deleteScopeStmt, deleteScope, id)
return err
}
const deleteScopeMember = `-- name: DeleteScopeMember :exec
DELETE FROM scope_member WHERE scope_id=? AND user_id=?
`
type DeleteScopeMemberParams struct {
ScopeID int `json:"scope_id"`
UserID string `json:"user_id"`
}
func (q *Queries) DeleteScopeMember(ctx context.Context, arg DeleteScopeMemberParams) error {
_, err := q.exec(ctx, q.deleteScopeMemberStmt, deleteScopeMember, arg.ScopeID, arg.UserID)
return err
}
const getScope = `-- name: GetScope :one
SELECT id, name, abbreviation FROM scope
WHERE id = ?
@@ -69,6 +101,21 @@ func (q *Queries) GetScopeWithDisplayName(ctx context.Context, arg GetScopeWithD
return i, err
}
const insertScope = `-- name: InsertScope :execresult
INSERT INTO scope (id, name, abbreviation)
VALUES (?, ?, ?)
`
type InsertScopeParams struct {
ID int `json:"id"`
Name string `json:"name"`
Abbreviation string `json:"abbreviation"`
}
func (q *Queries) InsertScope(ctx context.Context, arg InsertScopeParams) (sql.Result, error) {
return q.exec(ctx, q.insertScopeStmt, insertScope, arg.ID, arg.Name, arg.Abbreviation)
}
const listScopeMembers = `-- name: ListScopeMembers :many
SELECT user_id, name, owner FROM scope_member
WHERE scope_id = ?
@@ -173,3 +220,40 @@ func (q *Queries) ListScopesByUser(ctx context.Context, userID string) ([]ListSc
}
return items, nil
}
const updateScope = `-- name: UpdateScope :exec
UPDATE scope SET name = ?, abbreviation = ? WHERE id = ?
`
type UpdateScopeParams struct {
Name string `json:"name"`
Abbreviation string `json:"abbreviation"`
ID int `json:"id"`
}
func (q *Queries) UpdateScope(ctx context.Context, arg UpdateScopeParams) error {
_, err := q.exec(ctx, q.updateScopeStmt, updateScope, arg.Name, arg.Abbreviation, arg.ID)
return err
}
const updateScopeMember = `-- name: UpdateScopeMember :exec
REPLACE INTO scope_member (scope_id, user_id, name, owner)
VALUES (?, ?, ?, ?)
`
type UpdateScopeMemberParams struct {
ScopeID int `json:"scope_id"`
UserID string `json:"user_id"`
Name string `json:"name"`
Owner bool `json:"owner"`
}
func (q *Queries) UpdateScopeMember(ctx context.Context, arg UpdateScopeMemberParams) error {
_, err := q.exec(ctx, q.updateScopeMemberStmt, updateScopeMember,
arg.ScopeID,
arg.UserID,
arg.Name,
arg.Owner,
)
return err
}
internal/database/mysql/queries/scope.sql
+19
View File
@@ -26,3 +26,22 @@ WHERE id = ? AND sm.user_id = ?;
SELECT name FROM scope_member
WHERE user_id = ? AND scope_id = ?;
-- name: InsertScope :execresult
INSERT INTO scope (id, name, abbreviation)
VALUES (?, ?, ?);
-- name: UpdateScope :exec
UPDATE scope SET name = ?, abbreviation = ? WHERE id = ?;
-- name: UpdateScopeMember :exec
REPLACE INTO scope_member (scope_id, user_id, name, owner)
VALUES (?, ?, ?, ?);
-- name: DeleteScopeMember :exec
DELETE FROM scope_member WHERE scope_id=? AND user_id=?;
-- name: DeleteAllScopeMembers :exec
DELETE FROM scope_member WHERE scope_id=?;
-- name: DeleteScope :exec
DELETE FROM scope WHERE id=?;
internal/database/mysql/scopes.go
+113 -15
View File
@@ -4,12 +4,12 @@ import (
"context"
"database/sql"
"encoding/json"
"golang.org/x/sync/errgroup"
"sort"
"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
"golang.org/x/sync/errgroup"
"log"
"time"
)
type scopeRepository struct {
@@ -101,12 +101,10 @@ func (r *scopeRepository) Find(ctx context.Context, id int) (*models.Scope, erro
return nil
})
t := time.Now()
err = eg.Wait()
if err != nil {
return nil, err
}
log.Println(time.Since(t))
return res, nil
}
@@ -150,26 +148,126 @@ func (r *scopeRepository) ListByUser(ctx context.Context, userID string) ([]mode
}
func (r *scopeRepository) Create(ctx context.Context, scope models.ScopeEntry, owner models.ScopeMember) (*models.Scope, error) {
//TODO implement me
panic("implement me")
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return nil, err
}
defer tx.Rollback()
q := mysqlcore.New(tx)
res, err := q.InsertScope(ctx, mysqlcore.InsertScopeParams(scope))
if err != nil {
return nil, err
}
id, err := res.LastInsertId()
if err != nil {
return nil, err
}
err = q.UpdateScopeMember(ctx, mysqlcore.UpdateScopeMemberParams{
ScopeID: int(id),
UserID: owner.ID,
Name: owner.Name,
Owner: true,
})
err = tx.Commit()
if err != nil {
return nil, err
}
return &models.Scope{
ScopeEntry: models.ScopeEntry{
ID: int(id),
Name: scope.Name,
Abbreviation: scope.Abbreviation,
},
DisplayName: owner.Name,
Members: []models.ScopeMember{
{
ID: owner.ID,
Name: owner.Name,
Owner: true,
},
},
Projects: []models.ProjectEntry{},
Stats: []models.Stat{},
}, nil
}
func (r *scopeRepository) Update(ctx context.Context, scope models.ScopeEntry) error {
//TODO implement me
panic("implement me")
return mysqlcore.New(r.db).UpdateScope(ctx, mysqlcore.UpdateScopeParams{
Name: scope.Name,
Abbreviation: scope.Abbreviation,
ID: scope.ID,
})
}
func (r *scopeRepository) Delete(ctx context.Context, scope models.Scope) error {
//TODO implement me
panic("implement me")
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
q := mysqlcore.New(tx)
err = q.DeleteAllScopeMembers(ctx, scope.ID)
if err != nil {
return err
}
err = q.DeleteScope(ctx, scope.ID)
if err != nil {
return err
}
return tx.Commit()
}
func (r *scopeRepository) UpdateMember(ctx context.Context, scope models.Scope, member models.ScopeMember) (*models.Scope, error) {
//TODO implement me
panic("implement me")
err := mysqlcore.New(r.db).UpdateScopeMember(ctx, mysqlcore.UpdateScopeMemberParams{
ScopeID: scope.ID,
UserID: member.ID,
Name: member.Name,
Owner: member.Owner,
})
if err != nil {
return nil, err
}
found := false
scope.Members = append(scope.Members[:0:0], scope.Members...)
for i, member2 := range scope.Members {
if member2.ID == member.ID {
scope.Members[i] = member2
found = true
}
}
if !found {
scope.Members = append(scope.Members, member)
sort.Slice(scope.Members, func(i, j int) bool {
return scope.Members[i].Name < scope.Members[j].Name
})
}
return &scope, nil
}
func (r *scopeRepository) DeleteMember(ctx context.Context, scope models.Scope, userID string) (*models.Scope, error) {
//TODO implement me
panic("implement me")
err := mysqlcore.New(r.db).DeleteScopeMember(ctx, mysqlcore.DeleteScopeMemberParams{
ScopeID: scope.ID,
UserID: userID,
})
if err != nil {
return nil, err
}
newMembers := make([]models.ScopeMember, 0, len(scope.Members)-1)
for _, member := range scope.Members {
if member.ID != userID {
newMembers = append(newMembers, member)
}
}
scope.Members = newMembers
return &scope, nil
}