128 lines
3.4 KiB
Go
128 lines
3.4 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
|
|
"secunda-test/internal/domain"
|
|
)
|
|
|
|
type TaskService struct {
|
|
tasks TaskRepository
|
|
teams TeamRepository
|
|
cache TaskCache
|
|
}
|
|
|
|
func NewTaskService(tasks TaskRepository, teams TeamRepository, cache TaskCache) *TaskService {
|
|
return &TaskService{tasks: tasks, teams: teams, cache: cache}
|
|
}
|
|
|
|
func (s *TaskService) Create(ctx context.Context, userID int64, task domain.Task) (domain.Task, error) {
|
|
if task.TeamID == 0 || task.Title == "" {
|
|
return domain.Task{}, ErrBadRequest
|
|
}
|
|
if _, ok, err := s.teams.MemberRole(ctx, task.TeamID, userID); err != nil {
|
|
return domain.Task{}, err
|
|
} else if !ok {
|
|
return domain.Task{}, ErrForbidden
|
|
}
|
|
if task.AssigneeID != nil {
|
|
if _, ok, err := s.teams.MemberRole(ctx, task.TeamID, *task.AssigneeID); err != nil {
|
|
return domain.Task{}, err
|
|
} else if !ok {
|
|
return domain.Task{}, ErrBadRequest
|
|
}
|
|
}
|
|
task.CreatedBy = userID
|
|
created, err := s.tasks.Create(ctx, task)
|
|
if err == nil {
|
|
_ = s.cache.DeleteTeam(ctx, task.TeamID)
|
|
}
|
|
return created, err
|
|
}
|
|
|
|
func (s *TaskService) List(ctx context.Context, userID int64, filter domain.TaskFilter) ([]domain.Task, error) {
|
|
if filter.TeamID == 0 {
|
|
return nil, ErrBadRequest
|
|
}
|
|
if _, ok, err := s.teams.MemberRole(ctx, filter.TeamID, userID); err != nil {
|
|
return nil, err
|
|
} else if !ok {
|
|
return nil, ErrForbidden
|
|
}
|
|
if filter.Page < 1 {
|
|
filter.Page = 1
|
|
}
|
|
if filter.PageSize <= 0 || filter.PageSize > 100 {
|
|
filter.PageSize = 20
|
|
}
|
|
if cached, ok, err := s.cache.GetTasks(ctx, filter); err == nil && ok {
|
|
return cached, nil
|
|
}
|
|
tasks, err := s.tasks.List(ctx, filter)
|
|
if err == nil {
|
|
_ = s.cache.SetTasks(ctx, filter, tasks)
|
|
}
|
|
return tasks, err
|
|
}
|
|
|
|
func (s *TaskService) Update(ctx context.Context, userID, taskID int64, patch domain.Task) (domain.Task, error) {
|
|
current, err := s.tasks.Get(ctx, taskID)
|
|
if err != nil {
|
|
return domain.Task{}, err
|
|
}
|
|
role, ok, err := s.teams.MemberRole(ctx, current.TeamID, userID)
|
|
if err != nil {
|
|
return domain.Task{}, err
|
|
}
|
|
if !ok || (role == domain.RoleMember && current.CreatedBy != userID && (current.AssigneeID == nil || *current.AssigneeID != userID)) {
|
|
return domain.Task{}, ErrForbidden
|
|
}
|
|
if patch.Title != "" {
|
|
current.Title = patch.Title
|
|
}
|
|
if patch.Description != "" {
|
|
current.Description = patch.Description
|
|
}
|
|
if patch.Status != "" {
|
|
current.Status = patch.Status
|
|
}
|
|
if patch.AssigneeID != nil {
|
|
if _, ok, err := s.teams.MemberRole(ctx, current.TeamID, *patch.AssigneeID); err != nil {
|
|
return domain.Task{}, err
|
|
} else if !ok {
|
|
return domain.Task{}, ErrBadRequest
|
|
}
|
|
current.AssigneeID = patch.AssigneeID
|
|
}
|
|
updated, err := s.tasks.Update(ctx, current, userID)
|
|
if err == nil {
|
|
_ = s.cache.DeleteTeam(ctx, current.TeamID)
|
|
}
|
|
return updated, err
|
|
}
|
|
|
|
func (s *TaskService) History(ctx context.Context, userID, taskID int64) ([]domain.TaskHistory, error) {
|
|
task, err := s.tasks.Get(ctx, taskID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if _, ok, err := s.teams.MemberRole(ctx, task.TeamID, userID); err != nil {
|
|
return nil, err
|
|
} else if !ok {
|
|
return nil, ErrForbidden
|
|
}
|
|
return s.tasks.History(ctx, taskID)
|
|
}
|
|
|
|
func (s *TaskService) TeamSummary(ctx context.Context) ([]domain.TeamSummary, error) {
|
|
return s.tasks.TeamSummary(ctx)
|
|
}
|
|
|
|
func (s *TaskService) TopCreators(ctx context.Context) ([]domain.TopCreator, error) {
|
|
return s.tasks.TopCreators(ctx)
|
|
}
|
|
|
|
func (s *TaskService) InvalidAssignees(ctx context.Context) ([]domain.Task, error) {
|
|
return s.tasks.InvalidAssignees(ctx)
|
|
}
|