-
Notifications
You must be signed in to change notification settings - Fork 0
/
task_usecase.go
139 lines (116 loc) · 3.09 KB
/
task_usecase.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package usecases
import (
"github.com/pkg/errors"
"github.com/thewizardplusplus/go-exercises-backend/entities"
"gorm.io/gorm"
)
// TaskStorage ...
type TaskStorage interface {
entities.TaskGetter
GetTasks(userID uint, pagination entities.Pagination) ([]entities.Task, error)
CountTasks() (int64, error)
CreateTask(task entities.Task) (id uint, err error)
UpdateTask(id uint, task entities.Task) error
DeleteTask(id uint) error
}
// TaskUsecase ...
type TaskUsecase struct {
TaskStorage TaskStorage
}
// GetTasks ...
func (usecase TaskUsecase) GetTasks(
userID uint,
pagination entities.Pagination,
) (
entities.TaskGroup,
error,
) {
tasks, err := usecase.TaskStorage.GetTasks(userID, pagination)
if err != nil {
return entities.TaskGroup{}, errors.Wrap(err, "unable to get the tasks")
}
taskCount, err := usecase.TaskStorage.CountTasks()
if err != nil {
return entities.TaskGroup{}, errors.Wrap(err, "unable to count the tasks")
}
taskGroup := entities.TaskGroup{Tasks: tasks, TotalCount: taskCount}
for index := range taskGroup.Tasks {
taskGroup.Tasks[index].User.PasswordHash = ""
}
return taskGroup, nil
}
// GetTask ...
func (usecase TaskUsecase) GetTask(
userID uint,
taskID uint,
) (
entities.Task,
error,
) {
task, err := usecase.TaskStorage.GetTask(userID, taskID)
if err != nil {
return entities.Task{}, errors.Wrap(err, "unable to get the task")
}
task.User.PasswordHash = ""
return task, nil
}
// CreateTask ...
func (usecase TaskUsecase) CreateTask(
userID uint,
task entities.Task,
) (
entities.Task,
error,
) {
task.UserID = userID
if err := task.FormatBoilerplateCode(); err != nil {
return entities.Task{},
errors.Wrap(err, "unable to format the boilerplate code")
}
id, err := usecase.TaskStorage.CreateTask(task)
if err != nil {
return entities.Task{}, errors.Wrap(err, "unable to create the task")
}
idAsModel := entities.Task{Model: gorm.Model{ID: id}}
return idAsModel, nil
}
// UpdateTask ...
func (usecase TaskUsecase) UpdateTask(
userID uint,
taskID uint,
task entities.Task,
) error {
if err := usecase.checkAccessToTask(userID, taskID); err != nil {
return errors.Wrap(err, "unable to check access to the task")
}
if err := task.FormatBoilerplateCode(); err != nil {
return errors.Wrap(err, "unable to format the boilerplate code")
}
if err := usecase.TaskStorage.UpdateTask(taskID, task); err != nil {
return errors.Wrap(err, "unable to update the task")
}
return nil
}
// DeleteTask ...
func (usecase TaskUsecase) DeleteTask(userID uint, taskID uint) error {
if err := usecase.checkAccessToTask(userID, taskID); err != nil {
return errors.Wrap(err, "unable to check access to the task")
}
if err := usecase.TaskStorage.DeleteTask(taskID); err != nil {
return errors.Wrap(err, "unable to delete the task")
}
return nil
}
func (usecase TaskUsecase) checkAccessToTask(
userID uint,
taskID uint,
) error {
task, err := usecase.TaskStorage.GetTask(userID, taskID)
if err != nil {
return errors.Wrap(err, "unable to get the task")
}
if userID != task.UserID {
return entities.ErrManagerialAccessIsDenied
}
return nil
}