Add checklist item template API

internal/deployment/wire.go

@@ -11,6 +11,7 @@ import (
 	"com.raunlo.checklist/internal/server"
 	checklistV1 "com.raunlo.checklist/internal/server/v1/checklist"
 	checklistItemV1 "com.raunlo.checklist/internal/server/v1/checklistItem"
+	checklistItemTemplateV1 "com.raunlo.checklist/internal/server/v1/checklistItemTemplate"
 	wire "github.com/google/wire"
 )
 
@@ -32,10 +33,11 @@ func Init(configuration ApplicationConfiguration) Application {
 			repository.CreateChecklistItemRepository,
 		),
 		// checklist item template resource set
-		//wire.NewSet(controllerMapper.NewChecklistItemTemplateDtoMapper,
-		//	controllers.CreateChecklistItemTemplateController,
-		//	service.CreateChecklistItemTemplateService,
-		//	repository.CreateChecklistItemTemplateRepository),
+		wire.NewSet(
+			checklistItemTemplateV1.NewChecklistItemTemplateController,
+			service.CreateChecklistItemTemplateService,
+			repository.CreateChecklistItemTemplateRepository,
+		),
 		//controllers.CreateUpdateOrderController,
 		connection.NewDatabaseConnection,
 		wire.FieldsOf(new(ApplicationConfiguration), "DatabaseConfiguration"),

internal/repository/query/checklist_item_template.go

@@ -1,7 +1,11 @@
 package query
 
 import (
+	"context"
+	"errors"
+
 	"com.raunlo.checklist/internal/core/domain"
+	"github.com/jackc/pgx/v5"
 	"github.com/raunlo/pgx-with-automapper/pool"
 )
 
@@ -11,8 +15,10 @@ type PersistChecklistItemTemplateQueryFunction struct {
 
 func (p *PersistChecklistItemTemplateQueryFunction) GetTransactionalQueryFunction() func(tx pool.TransactionWrapper) (domain.ChecklistItemTemplate, error) {
 	return func(tx pool.TransactionWrapper) (domain.ChecklistItemTemplate, error) {
-		//TODO implement me
-		panic("implement me")
+		sql := `INSERT INTO TEMPLATE_ITEM(ID, NAME) VALUES(nextval('template_item_id'), @name) RETURNING ID`
+		row := tx.QueryRow(context.Background(), sql, pgx.NamedArgs{"name": "__template__"})
+		err := row.Scan(&p.checklistItemTemplate.Id)
+		return p.checklistItemTemplate, err
 	}
 
 }
@@ -23,8 +29,9 @@ type UpdateChecklistItemTemplateQueryFunction struct {
 
 func (u *UpdateChecklistItemTemplateQueryFunction) GetTransactionalQueryFunction() func(tx pool.TransactionWrapper) (bool, error) {
 	return func(tx pool.TransactionWrapper) (bool, error) {
-		//TODO implement me
-		panic("implement me")
+		sql := `UPDATE TEMPLATE_ITEM SET NAME = NAME WHERE ID = @id`
+		tag, err := tx.Exec(context.Background(), sql, pgx.NamedArgs{"id": u.checklistItemTemplate.Id})
+		return tag.RowsAffected() == 1, err
 	}
 }
 
@@ -34,8 +41,18 @@ type DeleteChecklistItemTemplateByIdQueryFunction struct {
 
 func (d *DeleteChecklistItemTemplateByIdQueryFunction) GetTransactionalQueryFunction() func(tx pool.TransactionWrapper) (bool, error) {
 	return func(tx pool.TransactionWrapper) (bool, error) {
-		//TODO implement me
-		panic("implement me")
+		_, err := tx.Exec(context.Background(), `DELETE FROM TEMPLATE_ITEM_ROW WHERE TEMPLATE_ITEM_ID = @id`, pgx.NamedArgs{"id": d.checklistItemTemplateId})
+		if err != nil {
+			return false, err
+		}
+		tag, err := tx.Exec(context.Background(), `DELETE FROM TEMPLATE_ITEM WHERE ID = @id`, pgx.NamedArgs{"id": d.checklistItemTemplateId})
+		if err != nil {
+			return false, err
+		}
+		if tag.RowsAffected() > 1 {
+			return false, errors.New("deleteChecklistItemTemplateById affected more than one row")
+		}
+		return tag.RowsAffected() == 1, nil
 	}
 
 }
@@ -46,8 +63,31 @@ type FindChecklistItemTemplateByIdQueryFunction struct {
 
 func (f FindChecklistItemTemplateByIdQueryFunction) GetQueryFunction() func(connection pool.Conn) (*domain.ChecklistItemTemplate, error) {
 	return func(connection pool.Conn) (*domain.ChecklistItemTemplate, error) {
-		//TODO implement me
-		panic("implement me")
+		sql := `SELECT t.ID, r.ID FROM TEMPLATE_ITEM t LEFT JOIN TEMPLATE_ITEM_ROW r ON t.ID = r.TEMPLATE_ITEM_ID WHERE t.ID = @id`
+		rows, err := connection.Query(context.Background(), sql, pgx.NamedArgs{"id": f.checklistItemTemplateId})
+		if err != nil {
+			return nil, err
+		}
+		defer rows.Close()
+
+		var template *domain.ChecklistItemTemplate
+		for rows.Next() {
+			var tId uint
+			var rId *uint
+			if err := rows.Scan(&tId, &rId); err != nil {
+				return nil, err
+			}
+			if template == nil {
+				template = &domain.ChecklistItemTemplate{Id: tId}
+			}
+			if rId != nil {
+				template.Rows = append(template.Rows, domain.ChecklistItemTemplateRow{Id: *rId})
+			}
+		}
+		if template == nil {
+			return nil, nil
+		}
+		return template, rows.Err()
 	}
 
 }
@@ -57,7 +97,36 @@ type GetAllChecklistItemTemplatesQueryFunction struct {
 
 func (g *GetAllChecklistItemTemplatesQueryFunction) GetQueryFunction() func(connection pool.Conn) ([]domain.ChecklistItemTemplate, error) {
 	return func(connection pool.Conn) ([]domain.ChecklistItemTemplate, error) {
-		//TODO implement me
-		panic("implement me")
+		sql := `SELECT t.ID, r.ID FROM TEMPLATE_ITEM t LEFT JOIN TEMPLATE_ITEM_ROW r ON t.ID = r.TEMPLATE_ITEM_ID ORDER BY t.ID, r.ID`
+		rows, err := connection.Query(context.Background(), sql)
+		if err != nil {
+			return nil, err
+		}
+		defer rows.Close()
+
+		templatesMap := map[uint]*domain.ChecklistItemTemplate{}
+		for rows.Next() {
+			var tId uint
+			var rId *uint
+			if err := rows.Scan(&tId, &rId); err != nil {
+				return nil, err
+			}
+			tpl := templatesMap[tId]
+			if tpl == nil {
+				tpl = &domain.ChecklistItemTemplate{Id: tId}
+				templatesMap[tId] = tpl
+			}
+			if rId != nil {
+				tpl.Rows = append(tpl.Rows, domain.ChecklistItemTemplateRow{Id: *rId})
+			}
+		}
+		if err := rows.Err(); err != nil {
+			return nil, err
+		}
+		templates := make([]domain.ChecklistItemTemplate, 0, len(templatesMap))
+		for _, t := range templatesMap {
+			templates = append(templates, *t)
+		}
+		return templates, nil
 	}
 }

internal/repository/query/checklist_item_template_row.go

@@ -1,7 +1,11 @@
 package query
 
 import (
+	"context"
+	"fmt"
+
 	"com.raunlo.checklist/internal/core/domain"
+	"github.com/jackc/pgx/v5"
 	"github.com/raunlo/pgx-with-automapper/pool"
 )
 
@@ -12,8 +16,32 @@ type PersistChecklistItemTemplateRowQueryFunction struct {
 
 func (p *PersistChecklistItemTemplateRowQueryFunction) GetTransactionalQueryFunction() func(tx pool.TransactionWrapper) ([]domain.ChecklistItemTemplateRow, error) {
 	return func(tx pool.TransactionWrapper) ([]domain.ChecklistItemTemplateRow, error) {
-		//TODO implement me
-		panic("implement me")
+		if len(p.checklistItemTemplateRows) == 0 {
+			return []domain.ChecklistItemTemplateRow{}, nil
+		}
+		namedArgs := pgx.NamedArgs{}
+		query := "INSERT INTO TEMPLATE_ITEM_ROW(ID, TEMPLATE_ITEM_ID, NAME) VALUES "
+
+		ids, err := (&GetSequenceValuesQuery{sequenceName: "template_item_row_id", numberOfValues: len(p.checklistItemTemplateRows)}).GetTransactionalQueryFunction()(tx)
+		if err != nil {
+			return nil, err
+		}
+		for i := range p.checklistItemTemplateRows {
+			rowPtr := &p.checklistItemTemplateRows[i]
+			rowPtr.Id = ids[i]
+			idParam := getIndexedSQLValueParamName(i, "rowId")
+			templateIdParam := getIndexedSQLValueParamName(i, "templateId")
+			nameParam := getIndexedSQLValueParamName(i, "rowName")
+			query += fmt.Sprintf("(@%s, @%s, @%s)", idParam, templateIdParam, nameParam)
+			if i != len(p.checklistItemTemplateRows)-1 {
+				query += ", "
+			}
+			namedArgs[idParam] = rowPtr.Id
+			namedArgs[templateIdParam] = p.checklistItemTemplateId
+			namedArgs[nameParam] = "__template_row__"
+		}
+		_, err = tx.Exec(context.Background(), query, namedArgs)
+		return p.checklistItemTemplateRows, err
 	}
 
 }
@@ -24,8 +52,37 @@ type UpdateChecklistItemTemplateRowsQueryFunction struct {
 }
 
 func (u *UpdateChecklistItemTemplateRowsQueryFunction) GetTransactionalQueryFunction() func(tx pool.TransactionWrapper) (bool, error) {
+	getQuery := func(index int, row domain.ChecklistItemTemplateRow) (string, pgx.NamedArgs) {
+		rowNameParam := getIndexedSQLValueParamName(index, "rowName")
+		templateIdParam := getIndexedSQLValueParamName(index, "templateId")
+		rowIdParam := getIndexedSQLValueParamName(index, "rowId")
+		sql := fmt.Sprintf(`UPDATE TEMPLATE_ITEM_ROW SET NAME = @%s WHERE ID = @%s AND TEMPLATE_ITEM_ID = @%s`, rowNameParam, rowIdParam, templateIdParam)
+		args := pgx.NamedArgs{
+			rowNameParam:    "__template_row__",
+			templateIdParam: u.checklistItemTemplateId,
+			rowIdParam:      row.Id,
+		}
+		return sql, args
+	}
 	return func(tx pool.TransactionWrapper) (bool, error) {
-		//TODO implement me
-		panic("implement me")
+		if len(u.checklistItemTemplateRows) == 0 {
+			return true, nil
+		}
+		batch := &pgx.Batch{}
+		for i, row := range u.checklistItemTemplateRows {
+			sql, args := getQuery(i, row)
+			batch.Queue(sql, args)
+		}
+		br := tx.SendBatch(context.Background(), batch)
+		defer br.Close()
+		rowsAffected := 0
+		for i := 0; i < batch.Len(); i++ {
+			tag, err := br.Exec()
+			if err != nil {
+				return false, err
+			}
+			rowsAffected += int(tag.RowsAffected())
+		}
+		return rowsAffected == batch.Len(), nil
 	}
 }

internal/repository/repository_factories.go

@@ -17,6 +17,8 @@ func CreateChecklistItemRepository(conn pool.Conn) repository.IChecklistItemsRep
 	}
 }
 
-func CreateChecklistItemTemplateRepository() repository.IChecklistItemTemplateRepository {
-	return &checklistItemTemplateRepository{}
+func CreateChecklistItemTemplateRepository(conn pool.Conn) repository.IChecklistItemTemplateRepository {
+	return &checklistItemTemplateRepository{
+		connection: conn,
+	}
 }

internal/server/factory.go

@@ -4,32 +4,37 @@ import (
 	v1 "com.raunlo.checklist/internal/server/v1"
 	checklistV1 "com.raunlo.checklist/internal/server/v1/checklist"
 	checklistItemV1 "com.raunlo.checklist/internal/server/v1/checklistItem"
+	checklistItemTemplateV1 "com.raunlo.checklist/internal/server/v1/checklistItemTemplate"
 	"github.com/gin-gonic/gin"
 )
 
 type IRoutes interface {
 	ConfigureRoutes()
 }
 type routes struct {
-	engine                  *gin.Engine
-	checklistController     checklistV1.IChecklistController
-	checklistItemController checklistItemV1.IChecklistItemController
+	engine                          *gin.Engine
+	checklistController             checklistV1.IChecklistController
+	checklistItemController         checklistItemV1.IChecklistItemController
+	checklistItemTemplateController checklistItemTemplateV1.IChecklistItemTemplateController
 }
 
 func NewRoutes(
 	engine *gin.Engine,
 	checklistController checklistV1.IChecklistController,
-	checklistItemController checklistItemV1.IChecklistItemController) IRoutes {
+	checklistItemController checklistItemV1.IChecklistItemController,
+	checklistItemTemplateController checklistItemTemplateV1.IChecklistItemTemplateController) IRoutes {
 
 	return &routes{
-		engine:                  engine,
-		checklistController:     checklistController,
-		checklistItemController: checklistItemController,
+		engine:                          engine,
+		checklistController:             checklistController,
+		checklistItemController:         checklistItemController,
+		checklistItemTemplateController: checklistItemTemplateController,
 	}
 }
 
 func (server *routes) ConfigureRoutes() {
 	v1.RegisterV1Endpoints(server.engine.Group("/"),
 		server.checklistController,
-		server.checklistItemController)
+		server.checklistItemController,
+		server.checklistItemTemplateController)
 }

internal/server/generator.go

@@ -4,3 +4,4 @@ package server
 // v1 version API
 //go:generate   go tool  github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen -o ./v1/checklist/server.gen.go -config ./v1/checklist/cfg.yaml ./../../openapi/api_v1.yaml
 //go:generate  go tool  github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen -o ./v1/checklistItem/server.gen.go -config ./v1/checklistItem/cfg.yaml ./../../openapi/api_v1.yaml
+//go:generate  go tool  github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen -o ./v1/checklistItemTemplate/server.gen.go -config ./v1/checklistItemTemplate/cfg.yaml ./../../openapi/api_v1.yaml

internal/server/v1/api_v1_factory.go

@@ -3,12 +3,15 @@ package v1
 import (
 	"com.raunlo.checklist/internal/server/v1/checklist"
 	"com.raunlo.checklist/internal/server/v1/checklistItem"
+	checklistItemTemplate "com.raunlo.checklist/internal/server/v1/checklistItemTemplate"
 	"github.com/gin-gonic/gin"
 )
 
 func RegisterV1Endpoints(gin *gin.RouterGroup,
 	checklistController checklist.IChecklistController,
-	checklistItemController checklistItem.IChecklistItemController) {
+	checklistItemController checklistItem.IChecklistItemController,
+	checklistItemTemplateController checklistItemTemplate.IChecklistItemTemplateController) {
 	checklist.RegisterHandlers(gin, checklist.NewStrictHandler(checklistController, nil))
 	checklistItem.RegisterHandlers(gin, checklistItem.NewStrictHandler(checklistItemController, nil))
+	checklistItemTemplate.RegisterHandlers(gin, checklistItemTemplate.NewStrictHandler(checklistItemTemplateController, nil))
 }

internal/server/v1/checklistItemTemplate/cfg.yaml

@@ -0,0 +1,8 @@
+package: checklistItemTemplate
+generate:
+  gin-server: true
+  models: true
+  strict-server: true
+output-options:
+  include-tags:
+    - checklistItemTemplate