Create Project api, service and repository

api/internal/project/api.go

@@ -0,0 +1,97 @@
+package project
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/pacholoamit/GO-TASK-MGR/common/log"
+	"github.com/pacholoamit/GO-TASK-MGR/pkg/dto"
+)
+
+func RegisterHandlers(r *echo.Echo, s Service, l log.Logger) {
+	res := resource{s, l}
+
+	r.GET("/projects", res.list)
+	r.POST("/project", res.create)
+	r.GET("/project/:id", res.get)
+	r.PUT("/project/:id", res.update)
+	r.DELETE("/projects/:id", res.delete)
+}
+
+type resource struct {
+	service Service
+	logger  log.Logger
+}
+
+func (r resource) list(c echo.Context) error {
+	r.logger.Info("Listing all tasks")
+	projects, err := r.service.List()
+	if err != nil {
+		r.logger.Error("Error when Getting all tasks:", err)
+		return c.JSON(http.StatusBadRequest, err.Error())
+	}
+	return c.JSON(http.StatusOK, projects)
+}
+
+func (r resource) get(c echo.Context) error {
+	r.logger.Info("Getting a task")
+	id, _ := strconv.Atoi(c.Param("id"))
+	project, err := r.service.Get(id)
+
+	if err != nil {
+		r.logger.Error("Error when Getting task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+	return c.JSON(http.StatusOK, project)
+}
+
+func (r resource) create(c echo.Context) error {
+	r.logger.Info("Creating a task")
+	project := new(dto.Project)
+
+	if err := c.Bind(project); err != nil {
+		r.logger.Error("Error when Binding task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+	if err := c.Validate(project); err != nil {
+		r.logger.Error("Error when Validating task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+	createdProject, err := r.service.Create(project)
+	if err != nil {
+		r.logger.Error("Error when Creating task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+	return c.JSON(http.StatusOK, createdProject)
+}
+
+func (r resource) update(c echo.Context) error {
+	r.logger.Info("Updating a task")
+	id, _ := strconv.Atoi(c.Param("id"))
+	project := new(dto.Project)
+
+	if err := c.Bind(project); err != nil {
+		r.logger.Error("Error when Binding task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+
+	updatedProject, err := r.service.Update(id, project)
+	if err != nil {
+		r.logger.Error("Error when Updating task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+	return c.JSON(http.StatusOK, updatedProject)
+}
+
+func (r resource) delete(c echo.Context) error {
+	r.logger.Info("Deleting a task")
+	id, _ := strconv.Atoi(c.Param("id"))
+
+	project, err := r.service.Delete(id)
+	if err != nil {
+		r.logger.Error("Error when Deleting task:", err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
+	}
+	return c.JSON(http.StatusOK, project)
+}

api/internal/project/repository.go

@@ -0,0 +1,69 @@
+package project
+
+import (
+	"github.com/pacholoamit/GO-TASK-MGR/common/log"
+	"github.com/pacholoamit/GO-TASK-MGR/pkg/dto"
+	"gorm.io/gorm"
+)
+
+type Repository interface {
+	List() ([]dto.Project, error)
+	Get(id int) (dto.Project, error)
+	Create(t *dto.Project) (*dto.Project, error)
+	Update(id int, t *dto.Project) (*dto.Project, error)
+	Delete(id int) (dto.Project, error)
+}
+
+type repository struct {
+	db     *gorm.DB
+	logger log.Logger
+}
+
+func NewRepository(db *gorm.DB, l log.Logger) Repository {
+	return repository{db, l}
+}
+
+func (r repository) List() ([]dto.Project, error) {
+	projects := []dto.Project{}
+	if err := r.db.Find(&projects).Error; err != nil {
+		r.logger.Error("Error when Getting all projects:", err)
+		return []dto.Project{}, err
+	}
+	return projects, nil
+}
+
+func (r repository) Get(id int) (dto.Project, error) {
+	project := dto.Project{}
+	if err := r.db.First(&project, id).Error; err != nil {
+		r.logger.Error("Error when Getting project:", err)
+		return dto.Project{}, err
+	}
+	return project, nil
+}
+
+func (r repository) Create(t *dto.Project) (*dto.Project, error) {
+	if err := r.db.Create(&t).Error; err != nil {
+		r.logger.Error("Error when Creating project:", err)
+		return new(dto.Project), err
+	}
+	return t, nil
+}
+
+func (r repository) Update(id int, t *dto.Project) (*dto.Project, error) {
+	project := new(dto.Project)
+
+	if err := r.db.Find(&project, id).Updates(&t).Error; err != nil {
+		r.logger.Error("Error when Updating project:", err)
+		return new(dto.Project), err
+	}
+	return project, nil
+}
+
+func (r repository) Delete(id int) (dto.Project, error) {
+	project := dto.Project{}
+	if err := r.db.First(&project, id).Delete(&project).Error; err != nil {
+		r.logger.Error("Error when Deleting project:", err)
+		return dto.Project{}, err
+	}
+	return project, nil
+}

api/internal/project/service.go

@@ -0,0 +1,86 @@
+package project
+
+import (
+	"errors"
+
+	"github.com/pacholoamit/GO-TASK-MGR/common/log"
+
+	"github.com/pacholoamit/GO-TASK-MGR/pkg/dto"
+)
+
+type Service interface {
+	List() ([]dto.Project, error)
+	Get(id int) (dto.Project, error)
+	Create(t *dto.Project) (*dto.Project, error)
+	Update(id int, t *dto.Project) (*dto.Project, error)
+	Delete(id int) (dto.Project, error)
+}
+
+type service struct {
+	repo   Repository
+	logger log.Logger
+}
+
+func NewService(r Repository, l log.Logger) Service {
+	return &service{
+		repo:   r,
+		logger: l,
+	}
+}
+
+func (s *service) List() ([]dto.Project, error) {
+	projects, err := s.repo.List()
+	if err != nil {
+		s.logger.Error("Error when Getting all projects:", err)
+		return []dto.Project{}, err
+	}
+	return projects, nil
+}
+
+func (s *service) Get(id int) (dto.Project, error) {
+	project, err := s.repo.Get(id)
+	if project.ID == 0 {
+		s.logger.Error("Error when Updating project:", err)
+		return project, errors.New("project not found")
+	}
+	if err != nil {
+		s.logger.Error("Error when Getting project:", err)
+		return project, err
+	}
+	return project, nil
+}
+
+func (s *service) Create(t *dto.Project) (*dto.Project, error) {
+	project, err := s.repo.Create(t)
+	if err != nil {
+		s.logger.Error("Error when Creating project:", err)
+		return project, err
+	}
+	return project, nil
+}
+
+func (s *service) Update(id int, t *dto.Project) (*dto.Project, error) {
+	project, err := s.repo.Update(id, t)
+	if project.ID == 0 {
+		s.logger.Error("Error when Updating project:", err)
+		return &dto.Project{}, errors.New("project not found")
+	}
+	if err != nil {
+		s.logger.Error("Error when Getting project:", err)
+		return &dto.Project{}, err
+	}
+	return project, nil
+}
+
+func (s *service) Delete(id int) (dto.Project, error) {
+	project, err := s.repo.Delete(id)
+	if project.ID == 0 {
+		s.logger.Error("Error when Deleting project:", err)
+		return dto.Project{}, errors.New("project not found")
+	}
+	if err != nil {
+		s.logger.Error("Error when Deleting project:", err)
+		return dto.Project{}, err
+	}
+	return project, nil
+}

api/internal/task/api.go

@@ -42,7 +42,7 @@ func (r resource) get(c echo.Context) error {
 	task, err := r.service.Get(id)
 	if err != nil {
 		r.logger.Error("Error when Getting task:", err)
-		return echo.NewHTTPError(http.StatusBadRequest, err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
 	}
 	return c.JSON(http.StatusOK, task)
 }
@@ -52,11 +52,11 @@ func (r resource) create(c echo.Context) error {
 	task := new(dto.Task)
 	if err := c.Bind(task); err != nil {
 		r.logger.Error("Error when Binding task:", err)
-		return echo.NewHTTPError(http.StatusBadRequest, err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
 	}
 	if err := c.Validate(task); err != nil {
 		r.logger.Error("Error when Validating task:", err)
-		return echo.NewHTTPError(http.StatusBadRequest, err)
+		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
 	}
 	createdTask, err := r.service.Create(task)
 	if err != nil {

api/internal/task/repository.go

@@ -2,7 +2,6 @@ package task
 
 import (
 	"github.com/pacholoamit/GO-TASK-MGR/common/log"
-
 	"github.com/pacholoamit/GO-TASK-MGR/pkg/dto"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
@@ -21,8 +20,8 @@ type repository struct {
 	logger log.Logger
 }
 
-func NewRepository(db *gorm.DB, logger log.Logger) Repository {
-	return repository{db, logger}
+func NewRepository(db *gorm.DB, l log.Logger) Repository {
+	return repository{db, l}
 }
 
 func (r repository) List() ([]dto.Task, error) {

api/internal/task/service.go

@@ -21,18 +21,18 @@ type service struct {
 	logger log.Logger
 }
 
-func NewService(repo Repository, logger log.Logger) Service {
+func NewService(r Repository, l log.Logger) Service {
 	return &service{
-		repo:   repo,
-		logger: logger,
+		repo:   r,
+		logger: l,
 	}
 }
 
 func (s *service) List() ([]dto.Task, error) {
 	tasks, err := s.repo.List()
 	if err != nil {
 		s.logger.Error("Error when Getting all tasks:", err)
-		return []dto.Task{}, err
+		return tasks, err
 	}
 	return tasks, nil
 }
@@ -45,7 +45,7 @@ func (s *service) Get(id int) (dto.Task, error) {
 	}
 	if err != nil {
 		s.logger.Error("Error when Getting task:", err)
-		return dto.Task{}, err
+		return task, err
 	}
 	return task, nil
 }
@@ -64,11 +64,11 @@ func (s *service) Update(id int, t *dto.Task) (*dto.Task, error) {
 
 	if task.ID == 0 {
 		s.logger.Info("Error when Updating task:", err)
-		return &dto.Task{}, errors.New("task not found")
+		return task, errors.New("task not found")
 	}
 	if err != nil {
 		s.logger.Error("Error when Updating task:", err)
-		return &dto.Task{}, err
+		return task, err
 	}
 	return task, nil
 }
@@ -77,11 +77,11 @@ func (s *service) Delete(id int) (dto.Task, error) {
 	task, err := s.repo.Delete(id)
 	if task.ID == 0 {
 		s.logger.Info("Error when Updating task:", err)
-		return dto.Task{}, errors.New("task not found")
+		return task, errors.New("task not found")
 	}
 	if err != nil {
 		s.logger.Error("Error when Deleting task:", err)
-		return dto.Task{}, err
+		return task, err
 	}
 	return task, nil
 }