Merge pull request #17 from RECYTHNG/develop

Develop

cmd/api/main.go

@@ -1,13 +1,9 @@
 package main
 
 import (
-	"log"
-
-	"github.com/robfig/cron/v3"
 	"github.com/sawalreverr/recything/config"
 	"github.com/sawalreverr/recything/internal/database"
 	"github.com/sawalreverr/recything/internal/server"
-	"github.com/sawalreverr/recything/internal/task/manage_task/repository"
 )
 
 func main() {
@@ -58,16 +54,6 @@ func main() {
 	db.InitComment()
 
 	app := server.NewEchoServer(conf, db)
-	c := cron.New()
-
-	taskRepo := repository.NewManageTaskRepository(db)
-	c.AddFunc("@daily", func() {
-		log.Println("Updating task challenge status...")
-		repository.UpdateTaskChallengeStatus(taskRepo)
-	})
-
-	c.Start()
-	defer c.Stop()
 
 	app.Start()
 }

go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.2.1
 	github.com/google/uuid v1.6.0
 	github.com/labstack/echo/v4 v4.12.0
-	github.com/robfig/cron/v3 v3.0.1
 	github.com/sashabaranov/go-openai v1.24.1
 	github.com/spf13/viper v1.18.2
 	golang.org/x/crypto v0.23.0

go.sum

@@ -119,8 +119,6 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=

internal/task/manage_task/entity/manage_task_entity.go

@@ -15,7 +15,7 @@ type TaskChallenge struct {
 	StartDate   time.Time
 	EndDate     time.Time
 	Point       int
-	Status      bool           `gorm:"default:true"`
+	Status      bool
 	TaskSteps   []TaskStep     `gorm:"foreignKey:TaskChallengeId"`
 	AdminId     string         `gorm:"index"`
 	Admin       admin.Admin    `gorm:"foreignKey:AdminId"`

internal/task/manage_task/repository/manage_task_repository.go

@@ -12,4 +12,5 @@ type ManageTaskRepository interface {
 	FindTask(id string) (*task.TaskChallenge, error)
 	UpdateTaskChallenge(taskChallenge *task.TaskChallenge, taskId string) (*task.TaskChallenge, error)
 	DeleteTaskChallenge(taskId string) error
+	UpdateTaskChallengeStatus() error
 }

internal/task/manage_task/repository/manage_task_repository_impl.go

@@ -15,7 +15,7 @@ type ManageTaskRepositoryImpl struct {
 	DB database.Database
 }
 
-func NewManageTaskRepository(db database.Database) *ManageTaskRepositoryImpl {
+func NewManageTaskRepository(db database.Database) ManageTaskRepository {
 	return &ManageTaskRepositoryImpl{DB: db}
 }
 
@@ -113,15 +113,16 @@ func (repository *ManageTaskRepositoryImpl) DeleteTaskChallenge(taskId string) e
 	return nil
 }
 
-// cronjob for update task challenge status
-func UpdateTaskChallengeStatus(db *ManageTaskRepositoryImpl) {
+func (repository *ManageTaskRepositoryImpl) UpdateTaskChallengeStatus() error {
 	now := time.Now()
-	result := db.DB.GetDB().Model(&entity.TaskChallenge{}).
+	result := repository.DB.GetDB().Model(&entity.TaskChallenge{}).
 		Where("end_date < ? AND status = ?", now, true).Update("status", false)
 
 	if result.Error != nil {
 		log.Printf("Error updating task challenge status: %v", result.Error)
+		return result.Error
 	} else {
 		log.Printf("Updated %d task challenge(s) status to false", result.RowsAffected)
+		return nil
 	}
 }

internal/task/manage_task/usecase/manage_task_usecase_impl.go

@@ -16,7 +16,7 @@ type ManageTaskUsecaseImpl struct {
 	ManageTaskRepository repository.ManageTaskRepository
 }
 
-func NewManageTaskUsecase(repository repository.ManageTaskRepository) *ManageTaskUsecaseImpl {
+func NewManageTaskUsecase(repository repository.ManageTaskRepository) ManageTaskUsecase {
 	return &ManageTaskUsecaseImpl{ManageTaskRepository: repository}
 }
 
@@ -51,6 +51,12 @@ func (usecase *ManageTaskUsecaseImpl) CreateTaskUsecase(request *dto.CreateTaskR
 	if errParsedEndDate != nil {
 		return nil, pkg.ErrParsedTime
 	}
+	var statusTask bool
+	if parsedEndDate.Before(time.Now()) {
+		statusTask = false
+	} else {
+		statusTask = true
+	}
 
 	taskChallange := &task.TaskChallenge{
 		ID:          id,
@@ -61,6 +67,7 @@ func (usecase *ManageTaskUsecaseImpl) CreateTaskUsecase(request *dto.CreateTaskR
 		StartDate:   parsedStartDate,
 		EndDate:     parsedEndDate,
 		Point:       request.Point,
+		Status:      statusTask,
 		TaskSteps:   []task.TaskStep{},
 		DeletedAt:   gorm.DeletedAt{},
 	}
@@ -85,6 +92,8 @@ func (usecase *ManageTaskUsecaseImpl) GetTaskChallengePagination(page int, limit
 	if err != nil {
 		return nil, 0, err
 	}
+	usecase.ManageTaskRepository.UpdateTaskChallengeStatus()
+
 	return tasks, total, nil
 }
 
@@ -148,7 +157,11 @@ func (usecase *ManageTaskUsecaseImpl) UpdateTaskChallengeUsecase(request *dto.Up
 			return nil, pkg.ErrParsedTime
 		}
 		tasks.EndDate = parsedEndDate
-		tasks.Status = true
+		if parsedEndDate.Before(time.Now()) {
+			tasks.Status = false
+		} else {
+			tasks.Status = true
+		}
 	}
 
 	if len(request.TaskSteps) != 0 {

internal/task/user_task/repository/user_task_repository_impl.go

@@ -11,7 +11,7 @@ type UserTaskRepositoryImpl struct {
 	DB database.Database
 }
 
-func NewUserTaskRepository(db database.Database) *UserTaskRepositoryImpl {
+func NewUserTaskRepository(db database.Database) UserTaskRepository {
 	return &UserTaskRepositoryImpl{DB: db}
 }
 

internal/task/user_task/usecase/user_task_usecase_impl.go

@@ -15,23 +15,23 @@ import (
 )
 
 type UserTaskUsecaseImpl struct {
-	ManageTaskRepository repository.UserTaskRepository
+	UserTaskRepository repository.UserTaskRepository
 }
 
-func NewUserTaskUsecase(repository repository.UserTaskRepository) *UserTaskUsecaseImpl {
-	return &UserTaskUsecaseImpl{ManageTaskRepository: repository}
+func NewUserTaskUsecase(repository repository.UserTaskRepository) UserTaskUsecase {
+	return &UserTaskUsecaseImpl{UserTaskRepository: repository}
 }
 
 func (usecase *UserTaskUsecaseImpl) GetAllTasksUsecase() ([]task.TaskChallenge, error) {
-	userTask, err := usecase.ManageTaskRepository.GetAllTasks()
+	userTask, err := usecase.UserTaskRepository.GetAllTasks()
 	if err != nil {
 		return nil, err
 	}
 	return userTask, nil
 }
 
 func (usecase *UserTaskUsecaseImpl) GetTaskByIdUsecase(id string) (*task.TaskChallenge, error) {
-	userTask, err := usecase.ManageTaskRepository.GetTaskById(id)
+	userTask, err := usecase.UserTaskRepository.GetTaskById(id)
 	if err != nil {
 		return nil, pkg.ErrTaskNotFound
 	}
@@ -40,7 +40,7 @@ func (usecase *UserTaskUsecaseImpl) GetTaskByIdUsecase(id string) (*task.TaskCha
 }
 
 func (usecase *UserTaskUsecaseImpl) CreateUserTaskUsecase(taskChallengeId string, userId string) (*user_task.UserTaskChallenge, error) {
-	findtask, errFindTask := usecase.ManageTaskRepository.FindTask(taskChallengeId)
+	findtask, errFindTask := usecase.UserTaskRepository.FindTask(taskChallengeId)
 
 	if errFindTask != nil {
 		return nil, pkg.ErrTaskNotFound
@@ -50,15 +50,15 @@ func (usecase *UserTaskUsecaseImpl) CreateUserTaskUsecase(taskChallengeId string
 		return nil, pkg.ErrTaskCannotBeFollowed
 	}
 
-	if _, err := usecase.ManageTaskRepository.FindUserTask(userId, taskChallengeId); err == nil {
+	if _, err := usecase.UserTaskRepository.FindUserTask(userId, taskChallengeId); err == nil {
 		return nil, pkg.ErrUserTaskExist
 	}
 
-	if _, err := usecase.ManageTaskRepository.FindUserHasSameTask(userId, taskChallengeId); err == nil {
+	if _, err := usecase.UserTaskRepository.FindUserHasSameTask(userId, taskChallengeId); err == nil {
 		return nil, pkg.ErrUserTaskExist
 	}
 
-	lastId, _ := usecase.ManageTaskRepository.FindLastIdTaskChallenge()
+	lastId, _ := usecase.UserTaskRepository.FindLastIdTaskChallenge()
 	id := helper.GenerateCustomID(lastId, "UT")
 	userTask := &user_task.UserTaskChallenge{
 		ID:              id,
@@ -67,27 +67,26 @@ func (usecase *UserTaskUsecaseImpl) CreateUserTaskUsecase(taskChallengeId string
 		AcceptedAt:      time.Now(),
 		ImageTask:       []user_task.UserTaskImage{},
 		StatusProgress:  "in_progress",
-		UserTaskSteps:   []user_task.UserTaskStep{}, // Initialize the UserTaskSteps
+		UserTaskSteps:   []user_task.UserTaskStep{},
 	}
 
-	// Attach TaskSteps to the UserTaskChallenge
 	userTask.TaskChallenge = *findtask
 
-	userTaskData, err := usecase.ManageTaskRepository.CreateUserTask(userTask)
+	userTaskData, err := usecase.UserTaskRepository.CreateUserTask(userTask)
 	if err != nil {
 		return nil, err
 	}
 	return userTaskData, nil
 }
 
 func (usecase *UserTaskUsecaseImpl) UploadImageTaskUsecase(request *dto.UploadImageTask, fileImage []*multipart.FileHeader, userId string, userTaskId string) (*user_task.UserTaskChallenge, error) {
-	findUserTask, errFind := usecase.ManageTaskRepository.FindUserTask(userId, userTaskId)
+	findUserTask, errFind := usecase.UserTaskRepository.FindUserTask(userId, userTaskId)
 
 	if errFind != nil {
 		return nil, pkg.ErrUserTaskNotFound
 	}
 
-	findTask, errFindTask := usecase.ManageTaskRepository.FindTask(findUserTask.TaskChallengeId)
+	findTask, errFindTask := usecase.UserTaskRepository.FindTask(findUserTask.TaskChallengeId)
 
 	if errFindTask != nil {
 		return nil, pkg.ErrTaskNotFound
@@ -106,7 +105,7 @@ func (usecase *UserTaskUsecaseImpl) UploadImageTaskUsecase(request *dto.UploadIm
 		return nil, pkg.ErrUserTaskDone
 	}
 
-	findUserSteps, errFindUserSteps := usecase.ManageTaskRepository.FindUserSteps(userTaskId)
+	findUserSteps, errFindUserSteps := usecase.UserTaskRepository.FindUserSteps(userTaskId)
 
 	if errFindUserSteps != nil {
 		return nil, errFindUserSteps
@@ -145,7 +144,7 @@ func (usecase *UserTaskUsecaseImpl) UploadImageTaskUsecase(request *dto.UploadIm
 		})
 	}
 
-	userTask, err := usecase.ManageTaskRepository.UploadImageTask(data, userTaskId)
+	userTask, err := usecase.UserTaskRepository.UploadImageTask(data, userTaskId)
 	if err != nil {
 		return nil, err
 	}
@@ -154,7 +153,7 @@ func (usecase *UserTaskUsecaseImpl) UploadImageTaskUsecase(request *dto.UploadIm
 }
 
 func (usecase *UserTaskUsecaseImpl) GetUserTaskByUserIdUsecase(userId string) ([]user_task.UserTaskChallenge, error) {
-	userTask, err := usecase.ManageTaskRepository.GetUserTaskByUserId(userId)
+	userTask, err := usecase.UserTaskRepository.GetUserTaskByUserId(userId)
 	if err != nil {
 		return nil, err
 	}
@@ -165,7 +164,7 @@ func (usecase *UserTaskUsecaseImpl) GetUserTaskByUserIdUsecase(userId string) ([
 }
 
 func (usecase *UserTaskUsecaseImpl) GetUserTaskDoneByUserIdUsecase(userId string) ([]user_task.UserTaskChallenge, error) {
-	userTask, err := usecase.ManageTaskRepository.GetUserTaskDoneByUserId(userId)
+	userTask, err := usecase.UserTaskRepository.GetUserTaskDoneByUserId(userId)
 	if err != nil {
 		return nil, err
 	}
@@ -176,7 +175,7 @@ func (usecase *UserTaskUsecaseImpl) GetUserTaskDoneByUserIdUsecase(userId string
 }
 
 func (usecase *UserTaskUsecaseImpl) UpdateUserTaskUsecase(request *dto.UpdateUserTaskRequest, fileImage []*multipart.FileHeader, userId string, userTaskId string) (*user_task.UserTaskChallenge, error) {
-	findUserTask, errFind := usecase.ManageTaskRepository.FindUserTask(userId, userTaskId)
+	findUserTask, errFind := usecase.UserTaskRepository.FindUserTask(userId, userTaskId)
 
 	if errFind != nil {
 		return nil, pkg.ErrUserTaskNotFound
@@ -186,7 +185,7 @@ func (usecase *UserTaskUsecaseImpl) UpdateUserTaskUsecase(request *dto.UpdateUse
 		return nil, pkg.ErrUserTaskNotReject
 	}
 
-	findTask, errFindTask := usecase.ManageTaskRepository.FindTask(findUserTask.TaskChallengeId)
+	findTask, errFindTask := usecase.UserTaskRepository.FindTask(findUserTask.TaskChallengeId)
 
 	if errFindTask != nil {
 		return nil, pkg.ErrTaskNotFound
@@ -225,15 +224,15 @@ func (usecase *UserTaskUsecaseImpl) UpdateUserTaskUsecase(request *dto.UpdateUse
 		})
 	}
 
-	userTask, err := usecase.ManageTaskRepository.UpdateUserTask(data, userTaskId)
+	userTask, err := usecase.UserTaskRepository.UpdateUserTask(data, userTaskId)
 	if err != nil {
 		return nil, err
 	}
 	return userTask, nil
 }
 
 func (usecase *UserTaskUsecaseImpl) GetUserTaskDetailsUsecase(userTaskId string, userId string) (*user_task.UserTaskChallenge, []*user_task.UserTaskImage, error) {
-	userTask, imageTask, err := usecase.ManageTaskRepository.GetUserTaskDetails(userTaskId, userId)
+	userTask, imageTask, err := usecase.UserTaskRepository.GetUserTaskDetails(userTaskId, userId)
 	if err != nil {
 		return nil, nil, pkg.ErrUserTaskNotFound
 	}
@@ -242,7 +241,7 @@ func (usecase *UserTaskUsecaseImpl) GetUserTaskDetailsUsecase(userTaskId string,
 
 func (usecase *UserTaskUsecaseImpl) GetHistoryPointByUserIdUsecase(userId string) ([]user_task.UserTaskChallenge, int, error) {
 
-	userTask, err := usecase.ManageTaskRepository.GetHistoryPointByUserId(userId)
+	userTask, err := usecase.UserTaskRepository.GetHistoryPointByUserId(userId)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -258,7 +257,7 @@ func (usecase *UserTaskUsecaseImpl) GetHistoryPointByUserIdUsecase(userId string
 }
 
 func (usecase *UserTaskUsecaseImpl) UpdateTaskStepUsecase(request *dto.UpdateTaskStepRequest, userId string) (*user_task.UserTaskChallenge, error) {
-	userTask, errUserTask := usecase.ManageTaskRepository.FindUserTask(userId, request.UserTaskId)
+	userTask, errUserTask := usecase.UserTaskRepository.FindUserTask(userId, request.UserTaskId)
 	if errUserTask != nil {
 		return nil, pkg.ErrUserTaskNotFound
 	}
@@ -271,15 +270,15 @@ func (usecase *UserTaskUsecaseImpl) UpdateTaskStepUsecase(request *dto.UpdateTas
 		return nil, pkg.ErrUserTaskAlreadyApprove
 	}
 
-	taskStep, errStep := usecase.ManageTaskRepository.FindTaskStep(request.TaskStepId, userTask.TaskChallengeId)
+	taskStep, errStep := usecase.UserTaskRepository.FindTaskStep(request.TaskStepId, userTask.TaskChallengeId)
 	if errStep != nil {
 		if errStep == gorm.ErrRecordNotFound {
 			return nil, pkg.ErrTaskStepNotFound
 		}
 		return nil, errStep
 	}
 
-	userTaskStep, errUserTaskStep := usecase.ManageTaskRepository.FindUserTaskStep(userTask.ID, taskStep.ID)
+	userTaskStep, errUserTaskStep := usecase.UserTaskRepository.FindUserTaskStep(userTask.ID, taskStep.ID)
 	if errUserTaskStep != nil {
 		return nil, pkg.ErrUserTaskStepNotFound
 	}
@@ -288,7 +287,8 @@ func (usecase *UserTaskUsecaseImpl) UpdateTaskStepUsecase(request *dto.UpdateTas
 		return nil, pkg.ErrUserTaskStepAlreadyCompleted
 	}
 
-	completedSteps, err := usecase.ManageTaskRepository.FindCompletedUserSteps(userTask.ID)
+	// Find completed user task steps
+	completedSteps, err := usecase.UserTaskRepository.FindCompletedUserSteps(userTask.ID)
 	if err != nil {
 		return nil, err
 	}
@@ -306,11 +306,11 @@ func (usecase *UserTaskUsecaseImpl) UpdateTaskStepUsecase(request *dto.UpdateTas
 	}
 
 	userTaskStep.Completed = true
-	if err := usecase.ManageTaskRepository.UpdateUserTaskStep(userTaskStep); err != nil {
+	if err := usecase.UserTaskRepository.UpdateUserTaskStep(userTaskStep); err != nil {
 		return nil, err
 	}
 
-	updatedUserTask, err := usecase.ManageTaskRepository.FindUserTask(userId, request.UserTaskId)
+	updatedUserTask, err := usecase.UserTaskRepository.FindUserTask(userId, request.UserTaskId)
 	if err != nil {
 		return nil, err
 	}
@@ -320,7 +320,7 @@ func (usecase *UserTaskUsecaseImpl) UpdateTaskStepUsecase(request *dto.UpdateTas
 
 func (usecase *UserTaskUsecaseImpl) GetUserTaskByUserTaskId(userId string, userTaskId string) (*user_task.UserTaskChallenge, error) {
 
-	userTask, err := usecase.ManageTaskRepository.FindUserTask(userId, userTaskId)
+	userTask, err := usecase.UserTaskRepository.FindUserTask(userId, userTaskId)
 
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -332,7 +332,7 @@ func (usecase *UserTaskUsecaseImpl) GetUserTaskByUserTaskId(userId string, userT
 }
 
 func (usecase *UserTaskUsecaseImpl) GetUserTaskRejectedByUserId(userId string, userTaskId string) (*user_task.UserTaskChallenge, error) {
-	userTask, errUserTask := usecase.ManageTaskRepository.GetUserTaskRejectedByUserId(userId, userTaskId)
+	userTask, errUserTask := usecase.UserTaskRepository.GetUserTaskRejectedByUserId(userId, userTaskId)
 
 	if errUserTask != nil {
 		if errors.Is(errUserTask, gorm.ErrRecordNotFound) {