stufflog/server
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add logging.

Browse Source
This commit is contained in:
gisle
2020-05-24 16:30:25 +02:00
parent e2c3b53d50
commit a4c019e67b
22 changed files with 883 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files
database/database.go
+1
View File
@@ -18,6 +18,7 @@ type Database interface {
Session() repositories.SessionRepository
Users() repositories.UserRepository
ProjectStatuses() repositories.ProjectStatusRepository
Logs() repositories.LogRepository
// Migrate the database.
Migrate() error
}
database/drivers/mysqldriver/db.go
+7
View File
@@ -23,6 +23,7 @@ type DB struct {
sessions *sessionRepository
users *userRepository
projectStatuses *projectStatusRepository
logs *logRepository
}
func (db *DB) Activities() repositories.ActivityRepository {
@@ -61,6 +62,10 @@ func (db *DB) ProjectStatuses() repositories.ProjectStatusRepository {
return db.projectStatuses
}
func (db *DB) Logs() repositories.LogRepository {
return db.logs
}
func (db *DB) Migrate() error {
err := goose.SetDialect("mysql")
if err != nil {
@@ -101,6 +106,7 @@ func Open(connectionString string) (*DB, error) {
projectStatuses := &projectStatusRepository{db: db}
issueTasks := &issueTaskRepository{db: db}
issueItems := &issueItemRepository{db: db}
logs := &logRepository{db: db}
return &DB{
db: db,
@@ -113,6 +119,7 @@ func Open(connectionString string) (*DB, error) {
users: users,
sessions: sessions,
projectStatuses: projectStatuses,
logs: logs,
}, nil
}
database/drivers/mysqldriver/logs.go
+281
View File
@@ -0,0 +1,281 @@
package mysqldriver
import (
"context"
"database/sql"
"git.aiterp.net/stufflog/server/internal/generate"
"git.aiterp.net/stufflog/server/internal/slerrors"
"git.aiterp.net/stufflog/server/models"
sq "github.com/Masterminds/squirrel"
"github.com/jmoiron/sqlx"
)
type logRepository struct {
db *sqlx.DB
}
func (r *logRepository) Find(ctx context.Context, id string) (*models.Log, error) {
log := models.Log{}
err := r.db.GetContext(ctx, &log, "SELECT * FROM log WHERE log_id=?", id)
if err != nil {
if err == sql.ErrNoRows {
return nil, slerrors.NotFound("Log")
}
return nil, err
}
err = r.db.SelectContext(ctx, &log.Items, "SELECT * FROM log_item WHERE log_id=?", id)
if err != nil {
return nil, err
}
err = r.db.SelectContext(ctx, &log.Tasks, "SELECT * FROM log_task WHERE log_id=?", id)
if err != nil {
return nil, err
}
return &log, nil
}
func (r *logRepository) List(ctx context.Context, filter models.LogFilter) ([]*models.Log, error) {
q := sq.Select("log.*").From("log").GroupBy("log.log_id").OrderBy("log.date")
if len(filter.IssueItemIDs) > 0 || len(filter.IssueIDs) > 0 {
q = q.LeftJoin("log_item ON log_item.log_id = log.log_id")
}
if len(filter.IssueTaskIDs) > 0 || len(filter.IssueIDs) > 0 {
q = q.LeftJoin("log_task ON log_task.log_id = log.log_id")
}
if len(filter.IssueIDs) > 0 {
q = q.Where(sq.Or{
sq.Eq{"log_task.issue_id": filter.IssueIDs},
sq.Eq{"log_item.issue_id": filter.IssueIDs},
})
}
if len(filter.IssueItemIDs) > 0 {
q = q.Where(sq.Eq{"log_item.issue_item_id": filter.IssueItemIDs})
}
if len(filter.IssueTaskIDs) > 0 {
q = q.Where(sq.Eq{"log_task.issue_task_id": filter.IssueTaskIDs})
}
if len(filter.LogIDs) > 0 {
q = q.Where(sq.Eq{"log.log_id": filter.LogIDs})
}
if len(filter.UserIDs) > 0 {
q = q.Where(sq.Eq{"log.user_id": filter.UserIDs})
}
if filter.FromDate != nil {
q = q.Where(sq.GtOrEq{"log.date": *filter.FromDate})
}
if filter.ToDate != nil {
q = q.Where(sq.LtOrEq{"log.date": *filter.ToDate})
}
query, args, err := q.ToSql()
if err != nil {
return nil, err
}
results := make([]*models.Log, 0, 16)
err = r.db.SelectContext(ctx, &results, query, args...)
if err != nil {
if err == sql.ErrNoRows {
return []*models.Log{}, nil
}
return nil, err
}
err = r.fill(ctx, results)
if err != nil {
return nil, err
}
return results, nil
}
func (r *logRepository) Insert(ctx context.Context, log models.Log) (*models.Log, error) {
tx, err := r.db.BeginTxx(ctx, nil)
if err != nil {
return nil, err
}
log.ID = generate.LogID()
_, err = tx.NamedExecContext(ctx, `
INSERT INTO log (
log_id, user_id, date, description
) VALUES (
:log_id, :user_id, :date, :description
)
`, log)
if err != nil {
_ = tx.Rollback()
return nil, err
}
for _, item := range log.Items {
item.LogID = log.ID
_, err = tx.NamedExecContext(ctx, `
INSERT INTO log_item (
log_id, issue_id, issue_item_id, amount
) VALUES (
:log_id, :issue_id, :issue_item_id, :amount
)
`, item)
if err != nil {
_ = tx.Rollback()
return nil, err
}
}
for _, task := range log.Tasks {
task.LogID = log.ID
_, err = tx.NamedExecContext(ctx, `
INSERT INTO log_task (
log_id, issue_id, issue_task_id, units, duration
) VALUES (
:log_id, :issue_id, :issue_task_id, :units, :duration
)
`, task)
if err != nil {
_ = tx.Rollback()
return nil, err
}
}
err = tx.Commit()
if err != nil {
_ = tx.Rollback()
return nil, err
}
return &log, nil
}
func (r *logRepository) Save(ctx context.Context, log models.Log) error {
tx, err := r.db.BeginTxx(ctx, nil)
if err != nil {
return err
}
_, err = tx.NamedExecContext(ctx, `
UPDATE log SET
date=:date,
description=:description
WHERE log_id=:log_id
`, log)
if err != nil {
_ = tx.Rollback()
return err
}
_, err = tx.ExecContext(ctx, "DELETE FROM log_item WHERE log_id=?", log.ID)
if err != nil {
_ = tx.Rollback()
return err
}
_, err = tx.ExecContext(ctx, "DELETE FROM log_task WHERE log_id=?", log.ID)
if err != nil {
_ = tx.Rollback()
return err
}
for _, item := range log.Items {
_, err = tx.NamedExecContext(ctx, `
INSERT INTO log_item (
log_id, issue_id, issue_item_id, amount
) VALUES (
:log_id, :issue_id, :issue_item_id, :amount
)
`, item)
if err != nil {
_ = tx.Rollback()
return err
}
}
for _, task := range log.Tasks {
_, err = tx.NamedExecContext(ctx, `
INSERT INTO log_task (
log_id, issue_id, issue_task_id, units, duration
) VALUES (
:log_id, :issue_id, :issue_task_id, :units, :duration
)
`, task)
if err != nil {
_ = tx.Rollback()
return err
}
}
err = tx.Commit()
if err != nil {
_ = tx.Rollback()
return err
}
return nil
}
func (r *logRepository) Delete(ctx context.Context, log models.Log) error {
tx, err := r.db.BeginTxx(ctx, nil)
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, "DELETE FROM log WHERE log_id=?", log.ID)
if err != nil {
_ = tx.Rollback()
return err
}
_, err = tx.ExecContext(ctx, "DELETE FROM log_item WHERE log_id=?", log.ID)
if err != nil {
_ = tx.Rollback()
return err
}
_, err = tx.ExecContext(ctx, "DELETE FROM log_task WHERE log_id=?", log.ID)
if err != nil {
_ = tx.Rollback()
return err
}
return tx.Commit()
}
func (r *logRepository) fill(ctx context.Context, logs []*models.Log) error {
logMap := make(map[string]int, len(logs))
ids := make([]string, len(logs))
for i, log := range logs {
ids[i] = log.ID
logMap[log.ID] = i
}
itemsQuery, itemsArgs, err := sq.Select("*").From("log_item").Where(sq.Eq{"log_id": ids}).ToSql()
if err != nil {
return err
}
tasksQuery, tasksArgs, err := sq.Select("*").From("log_task").Where(sq.Eq{"log_id": ids}).ToSql()
if err != nil {
return err
}
items := make([]models.LogItem, 0, len(logs)*3)
err = r.db.SelectContext(ctx, &items, itemsQuery, itemsArgs...)
if err != nil {
return err
}
for _, item := range items {
log := logs[logMap[item.LogID]]
log.Items = append(log.Items, item)
}
tasks := make([]models.LogTask, 0, len(logs)*3)
err = r.db.SelectContext(ctx, &tasks, tasksQuery, tasksArgs...)
if err != nil {
return err
}
for _, task := range tasks {
log := logs[logMap[task.LogID]]
log.Tasks = append(log.Tasks, task)
}
return nil
}
database/repositories/logrepository.go
+14
View File
@@ -0,0 +1,14 @@
package repositories
import (
"context"
"git.aiterp.net/stufflog/server/models"
)
type LogRepository interface {
Find(ctx context.Context, id string) (*models.Log, error)
List(ctx context.Context, filter models.LogFilter) ([]*models.Log, error)
Insert(ctx context.Context, log models.Log) (*models.Log, error)
Save(ctx context.Context, log models.Log) error
Delete(ctx context.Context, log models.Log) error
}