aboutsummaryrefslogtreecommitdiffstats
path: root/internal/chore
diff options
context:
space:
mode:
Diffstat (limited to 'internal/chore')
-rw-r--r--internal/chore/handler.go974
-rw-r--r--internal/chore/model/model.go72
-rw-r--r--internal/chore/repo/repository.go216
-rw-r--r--internal/chore/scheduler.go145
4 files changed, 1407 insertions, 0 deletions
diff --git a/internal/chore/handler.go b/internal/chore/handler.go
new file mode 100644
index 0000000..bc90c4c
--- /dev/null
+++ b/internal/chore/handler.go
@@ -0,0 +1,974 @@
+package chore
+
+import (
+ "encoding/json"
+ "fmt"
+ "html"
+ "log"
+ "math"
+ "math/rand"
+ "strconv"
+ "strings"
+ "time"
+
+ auth "donetick.com/core/internal/authorization"
+ chModel "donetick.com/core/internal/chore/model"
+ chRepo "donetick.com/core/internal/chore/repo"
+ cRepo "donetick.com/core/internal/circle/repo"
+ nRepo "donetick.com/core/internal/notifier/repo"
+ nps "donetick.com/core/internal/notifier/service"
+ telegram "donetick.com/core/internal/notifier/telegram"
+ tRepo "donetick.com/core/internal/thing/repo"
+ uModel "donetick.com/core/internal/user/model"
+ "donetick.com/core/logging"
+ jwt "github.com/appleboy/gin-jwt/v2"
+ "github.com/gin-gonic/gin"
+)
+
+type ThingTrigger struct {
+ ID int `json:"thingID" binding:"required"`
+ TriggerState string `json:"triggerState" binding:"required"`
+ Condition string `json:"condition"`
+}
+
+type ChoreReq struct {
+ Name string `json:"name" binding:"required"`
+ FrequencyType string `json:"frequencyType"`
+ ID int `json:"id"`
+ DueDate string `json:"dueDate"`
+ Assignees []chModel.ChoreAssignees `json:"assignees"`
+ AssignStrategy string `json:"assignStrategy" binding:"required"`
+ AssignedTo int `json:"assignedTo"`
+ IsRolling bool `json:"isRolling"`
+ IsActive bool `json:"isActive"`
+ Frequency int `json:"frequency"`
+ FrequencyMetadata *chModel.FrequencyMetadata `json:"frequencyMetadata"`
+ Notification bool `json:"notification"`
+ NotificationMetadata *chModel.NotificationMetadata `json:"notificationMetadata"`
+ Labels []string `json:"labels"`
+ ThingTrigger *ThingTrigger `json:"thingTrigger"`
+}
+type Handler struct {
+ choreRepo *chRepo.ChoreRepository
+ circleRepo *cRepo.CircleRepository
+ notifier *telegram.TelegramNotifier
+ nPlanner *nps.NotificationPlanner
+ nRepo *nRepo.NotificationRepository
+ tRepo *tRepo.ThingRepository
+}
+
+func NewHandler(cr *chRepo.ChoreRepository, circleRepo *cRepo.CircleRepository, nt *telegram.TelegramNotifier,
+ np *nps.NotificationPlanner, nRepo *nRepo.NotificationRepository, tRepo *tRepo.ThingRepository) *Handler {
+ return &Handler{
+ choreRepo: cr,
+ circleRepo: circleRepo,
+ notifier: nt,
+ nPlanner: np,
+ nRepo: nRepo,
+ tRepo: tRepo,
+ }
+}
+
+func (h *Handler) getChores(c *gin.Context) {
+ u, ok := auth.CurrentUser(c)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current circle",
+ })
+ return
+ }
+ chores, err := h.choreRepo.GetChores(c, u.CircleID, u.ID)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chores",
+ })
+ return
+ }
+
+ c.JSON(200, gin.H{
+ "res": chores,
+ })
+}
+
+func (h *Handler) getChore(c *gin.Context) {
+
+ currentUser, ok := auth.CurrentUser(c)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current user",
+ })
+ return
+ }
+
+ rawID := c.Param("id")
+ id, err := strconv.Atoi(rawID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+
+ chore, err := h.choreRepo.GetChore(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+ isAssignee := false
+
+ for _, assignee := range chore.Assignees {
+ if assignee.UserID == currentUser.ID {
+ isAssignee = true
+ break
+ }
+ }
+
+ if currentUser.ID != chore.CreatedBy && !isAssignee {
+ c.JSON(403, gin.H{
+ "error": "You are not allowed to view this chore",
+ })
+ return
+ }
+
+ c.JSON(200, gin.H{
+ "res": chore,
+ })
+}
+
+func (h *Handler) createChore(c *gin.Context) {
+ logger := logging.FromContext(c)
+ currentUser, ok := auth.CurrentUser(c)
+
+ logger.Debug("Create chore", "currentUser", currentUser)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current user",
+ })
+ return
+ }
+ // Validate chore:
+ var choreReq ChoreReq
+ if err := c.ShouldBindJSON(&choreReq); err != nil {
+ log.Print(err)
+ c.JSON(400, gin.H{
+ "error": "Invalid request",
+ })
+ return
+ }
+
+ circleUsers, err := h.circleRepo.GetCircleUsers(c, currentUser.CircleID)
+ for _, assignee := range choreReq.Assignees {
+ userFound := false
+ for _, circleUser := range circleUsers {
+ if assignee.UserID == circleUser.UserID {
+ userFound = true
+
+ break
+
+ }
+ }
+ if !userFound {
+ c.JSON(400, gin.H{
+ "error": "Assignee not found in circle",
+ })
+ return
+ }
+
+ }
+ if choreReq.AssignedTo <= 0 && len(choreReq.Assignees) > 0 {
+ // if the assigned to field is not set, randomly assign the chore to one of the assignees
+ choreReq.AssignedTo = choreReq.Assignees[rand.Intn(len(choreReq.Assignees))].UserID
+ }
+
+ var dueDate *time.Time
+
+ if choreReq.DueDate != "" {
+ rawDueDate, err := time.Parse(time.RFC3339, choreReq.DueDate)
+ rawDueDate = rawDueDate.UTC()
+ dueDate = &rawDueDate
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid date",
+ })
+ return
+ }
+
+ } else {
+ c.JSON(400, gin.H{
+ "error": "Due date is required",
+ })
+ return
+
+ }
+
+ freqencyMetadataBytes, err := json.Marshal(choreReq.FrequencyMetadata)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error marshalling frequency metadata",
+ })
+ return
+ }
+ stringFrequencyMetadata := string(freqencyMetadataBytes)
+
+ notificationMetadataBytes, err := json.Marshal(choreReq.NotificationMetadata)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error marshalling notification metadata",
+ })
+ return
+ }
+ stringNotificationMetadata := string(notificationMetadataBytes)
+
+ var stringLabels *string
+ if len(choreReq.Labels) > 0 {
+ var escapedLabels []string
+ for _, label := range choreReq.Labels {
+ escapedLabels = append(escapedLabels, html.EscapeString(label))
+ }
+
+ labels := strings.Join(escapedLabels, ",")
+ stringLabels = &labels
+ }
+ createdChore := &chModel.Chore{
+
+ Name: choreReq.Name,
+ FrequencyType: choreReq.FrequencyType,
+ Frequency: choreReq.Frequency,
+ FrequencyMetadata: &stringFrequencyMetadata,
+ NextDueDate: dueDate,
+ AssignStrategy: choreReq.AssignStrategy,
+ AssignedTo: choreReq.AssignedTo,
+ IsRolling: choreReq.IsRolling,
+ UpdatedBy: currentUser.ID,
+ IsActive: true,
+ Notification: choreReq.Notification,
+ NotificationMetadata: &stringNotificationMetadata,
+ Labels: stringLabels,
+ CreatedBy: currentUser.ID,
+ CreatedAt: time.Now().UTC(),
+ CircleID: currentUser.CircleID,
+ }
+ id, err := h.choreRepo.CreateChore(c, createdChore)
+ createdChore.ID = id
+
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error creating chore",
+ })
+ return
+ }
+
+ var choreAssignees []*chModel.ChoreAssignees
+ for _, assignee := range choreReq.Assignees {
+ choreAssignees = append(choreAssignees, &chModel.ChoreAssignees{
+ ChoreID: id,
+ UserID: assignee.UserID,
+ })
+ }
+
+ if err := h.choreRepo.UpdateChoreAssignees(c, choreAssignees); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error adding chore assignees",
+ })
+ return
+ }
+ go func() {
+ h.nPlanner.GenerateNotifications(c, createdChore)
+ }()
+ shouldReturn := HandleThingAssociation(choreReq, h, c, currentUser)
+ if shouldReturn {
+ return
+ }
+ c.JSON(200, gin.H{
+ "res": id,
+ })
+}
+
+func (h *Handler) editChore(c *gin.Context) {
+ // logger := logging.FromContext(c)
+ currentUser, ok := auth.CurrentUser(c)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current user",
+ })
+ return
+ }
+
+ var choreReq ChoreReq
+ if err := c.ShouldBindJSON(&choreReq); err != nil {
+ log.Print(err)
+ c.JSON(400, gin.H{
+ "error": "Invalid request",
+ })
+ return
+ }
+
+ circleUsers, err := h.circleRepo.GetCircleUsers(c, currentUser.CircleID)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting circle users",
+ })
+ return
+ }
+
+ existedChoreAssignees, err := h.choreRepo.GetChoreAssignees(c, choreReq.ID)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore assignees",
+ })
+ return
+ }
+
+ var choreAssigneesToAdd []*chModel.ChoreAssignees
+ var choreAssigneesToDelete []*chModel.ChoreAssignees
+
+ // filter assignees that not in the circle
+ for _, assignee := range choreReq.Assignees {
+ userFound := false
+ for _, circleUser := range circleUsers {
+ if assignee.UserID == circleUser.UserID {
+ userFound = true
+ break
+ }
+ }
+ if !userFound {
+ c.JSON(400, gin.H{
+ "error": "Assignee not found in circle",
+ })
+ return
+ }
+ userAlreadyAssignee := false
+ for _, existedChoreAssignee := range existedChoreAssignees {
+ if existedChoreAssignee.UserID == assignee.UserID {
+ userAlreadyAssignee = true
+ break
+ }
+ }
+ if !userAlreadyAssignee {
+ choreAssigneesToAdd = append(choreAssigneesToAdd, &chModel.ChoreAssignees{
+ ChoreID: choreReq.ID,
+ UserID: assignee.UserID,
+ })
+ }
+ }
+
+ // remove assignees if they are not in the assignees list anymore
+ for _, existedChoreAssignee := range existedChoreAssignees {
+ userFound := false
+ for _, assignee := range choreReq.Assignees {
+ if existedChoreAssignee.UserID == assignee.UserID {
+ userFound = true
+ break
+ }
+ }
+ if !userFound {
+ choreAssigneesToDelete = append(choreAssigneesToDelete, existedChoreAssignee)
+ }
+ }
+
+ var dueDate *time.Time
+
+ if choreReq.DueDate != "" {
+ rawDueDate, err := time.Parse(time.RFC3339, choreReq.DueDate)
+ rawDueDate = rawDueDate.UTC()
+ dueDate = &rawDueDate
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid date",
+ })
+ return
+ }
+
+ }
+
+ // validate assignedTo part of the assignees:
+ assigneeFound := false
+ for _, assignee := range choreReq.Assignees {
+ if assignee.UserID == choreReq.AssignedTo {
+ assigneeFound = true
+ break
+ }
+ }
+ if !assigneeFound {
+ c.JSON(400, gin.H{
+ "error": "Assigned to not found in assignees",
+ })
+ return
+ }
+
+ if choreReq.AssignedTo <= 0 && len(choreReq.Assignees) > 0 {
+ // if the assigned to field is not set, randomly assign the chore to one of the assignees
+ choreReq.AssignedTo = choreReq.Assignees[rand.Intn(len(choreReq.Assignees))].UserID
+ }
+ oldChore, err := h.choreRepo.GetChore(c, choreReq.ID)
+
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+ if currentUser.ID != oldChore.CreatedBy {
+ c.JSON(403, gin.H{
+ "error": "You are not allowed to edit this chore",
+ })
+ return
+ }
+ freqencyMetadataBytes, err := json.Marshal(choreReq.FrequencyMetadata)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error marshalling frequency metadata",
+ })
+ return
+ }
+
+ stringFrequencyMetadata := string(freqencyMetadataBytes)
+
+ notificationMetadataBytes, err := json.Marshal(choreReq.NotificationMetadata)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error marshalling notification metadata",
+ })
+ return
+ }
+ stringNotificationMetadata := string(notificationMetadataBytes)
+
+ // escape special characters in labels and store them as a string :
+ var stringLabels *string
+ if len(choreReq.Labels) > 0 {
+ var escapedLabels []string
+ for _, label := range choreReq.Labels {
+ escapedLabels = append(escapedLabels, html.EscapeString(label))
+ }
+
+ labels := strings.Join(escapedLabels, ",")
+ stringLabels = &labels
+ }
+ updatedChore := &chModel.Chore{
+ ID: choreReq.ID,
+ Name: choreReq.Name,
+ FrequencyType: choreReq.FrequencyType,
+ Frequency: choreReq.Frequency,
+ FrequencyMetadata: &stringFrequencyMetadata,
+ // Assignees: &assignees,
+ NextDueDate: dueDate,
+ AssignStrategy: choreReq.AssignStrategy,
+ AssignedTo: choreReq.AssignedTo,
+ IsRolling: choreReq.IsRolling,
+ IsActive: choreReq.IsActive,
+ Notification: choreReq.Notification,
+ NotificationMetadata: &stringNotificationMetadata,
+ Labels: stringLabels,
+ CircleID: oldChore.CircleID,
+ UpdatedBy: currentUser.ID,
+ CreatedBy: oldChore.CreatedBy,
+ CreatedAt: oldChore.CreatedAt,
+ }
+ if err := h.choreRepo.UpsertChore(c, updatedChore); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error adding chore",
+ })
+ return
+ }
+ if len(choreAssigneesToAdd) > 0 {
+ err = h.choreRepo.UpdateChoreAssignees(c, choreAssigneesToAdd)
+
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error updating chore assignees",
+ })
+ return
+ }
+ }
+ if len(choreAssigneesToDelete) > 0 {
+ err = h.choreRepo.DeleteChoreAssignees(c, choreAssigneesToDelete)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error deleting chore assignees",
+ })
+ return
+ }
+ }
+ go func() {
+ h.nPlanner.GenerateNotifications(c, updatedChore)
+ }()
+ if oldChore.ThingChore.ThingID != 0 {
+ // TODO: Add check to see if dissociation is necessary
+ h.tRepo.DissociateThingWithChore(c, oldChore.ThingChore.ThingID, oldChore.ID)
+
+ }
+ shouldReturn := HandleThingAssociation(choreReq, h, c, currentUser)
+ if shouldReturn {
+ return
+ }
+
+ c.JSON(200, gin.H{
+ "message": "Chore added successfully",
+ })
+}
+
+func HandleThingAssociation(choreReq ChoreReq, h *Handler, c *gin.Context, currentUser *uModel.User) bool {
+ if choreReq.ThingTrigger != nil {
+ thing, err := h.tRepo.GetThingByID(c, choreReq.ThingTrigger.ID)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting thing",
+ })
+ return true
+ }
+ if thing.UserID != currentUser.ID {
+ c.JSON(403, gin.H{
+ "error": "You are not allowed to trigger this thing",
+ })
+ return true
+ }
+ if err := h.tRepo.AssociateThingWithChore(c, choreReq.ThingTrigger.ID, choreReq.ID, choreReq.ThingTrigger.TriggerState, choreReq.ThingTrigger.Condition); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error associating thing with chore",
+ })
+ return true
+ }
+
+ }
+ return false
+}
+
+func (h *Handler) deleteChore(c *gin.Context) {
+ // logger := logging.FromContext(c)
+ currentUser, ok := auth.CurrentUser(c)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current user",
+ })
+ return
+ }
+
+ rawID := c.Param("id")
+ id, err := strconv.Atoi(rawID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+ // check if the user is the owner of the chore before deleting
+ if err := h.choreRepo.IsChoreOwner(c, id, currentUser.ID); err != nil {
+ c.JSON(403, gin.H{
+ "error": "You are not allowed to delete this chore",
+ })
+ return
+ }
+
+ if err := h.choreRepo.DeleteChore(c, id); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error deleting chore",
+ })
+ return
+ }
+ h.nRepo.DeleteAllChoreNotifications(id)
+ c.JSON(200, gin.H{
+ "message": "Chore deleted successfully",
+ })
+}
+
+// func (h *Handler) createChore(c *gin.Context) {
+// logger := logging.FromContext(c)
+// currentUser, ok := auth.CurrentUser(c)
+
+// logger.Debug("Create chore", "currentUser", currentUser)
+// if !ok {
+// c.JSON(500, gin.H{
+// "error": "Error getting current user",
+// })
+// return
+// }
+// id, err := h.choreRepo.CreateChore(currentUser.ID, currentUser.CircleID)
+// if err != nil {
+// c.JSON(500, gin.H{
+// "error": "Error creating chore",
+// })
+// return
+// }
+
+// c.JSON(200, gin.H{
+// "res": id,
+// })
+// }
+
+func (h *Handler) updateAssignee(c *gin.Context) {
+ rawID := c.Param("id")
+ id, err := strconv.Atoi(rawID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+ type AssigneeReq struct {
+ AssignedTo int `json:"assignedTo" binding:"required"`
+ UpdatedBy int `json:"updatedBy" binding:"required"`
+ }
+
+ var assigneeReq AssigneeReq
+ if err := c.ShouldBindJSON(&assigneeReq); err != nil {
+ log.Print(err)
+ c.JSON(400, gin.H{
+ "error": "Invalid request",
+ })
+ return
+ }
+ chore, err := h.choreRepo.GetChore(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+ // confirm that the assignee is one of the assignees:
+ assigneeFound := false
+ for _, assignee := range chore.Assignees {
+
+ if assignee.UserID == assigneeReq.AssignedTo {
+ assigneeFound = true
+ break
+ }
+ }
+ if !assigneeFound {
+ c.JSON(400, gin.H{
+ "error": "Assignee not found in assignees",
+ })
+ return
+ }
+
+ chore.UpdatedBy = assigneeReq.UpdatedBy
+ chore.AssignedTo = assigneeReq.AssignedTo
+ if err := h.choreRepo.UpsertChore(c, chore); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error updating assignee",
+ })
+ return
+ }
+
+ c.JSON(200, gin.H{
+ "res": chore,
+ })
+}
+
+func (h *Handler) skipChore(c *gin.Context) {
+ rawID := c.Param("id")
+ id, err := strconv.Atoi(rawID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+
+ chore, err := h.choreRepo.GetChore(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+ newDueDate, err := scheduleNextDueDate(chore, chore.NextDueDate.UTC())
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error scheduling next due date",
+ })
+ return
+ }
+ chore.NextDueDate = newDueDate
+ if err := h.choreRepo.UpsertChore(c, chore); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error skipping chore",
+ })
+ return
+ }
+ if err := h.choreRepo.UpsertChore(c, chore); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error skipping chore",
+ })
+ return
+ }
+ c.JSON(200, gin.H{
+ "res": chore,
+ })
+}
+
+func (h *Handler) updateDueDate(c *gin.Context) {
+ currentUser, ok := auth.CurrentUser(c)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current user",
+ })
+ return
+ }
+
+ type DueDateReq struct {
+ DueDate string `json:"dueDate" binding:"required"`
+ }
+
+ var dueDateReq DueDateReq
+ if err := c.ShouldBindJSON(&dueDateReq); err != nil {
+ log.Print(err)
+ c.JSON(400, gin.H{
+ "error": "Invalid request",
+ })
+ return
+ }
+
+ rawID := c.Param("id")
+ id, err := strconv.Atoi(rawID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+
+ rawDueDate, err := time.Parse(time.RFC3339, dueDateReq.DueDate)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid date",
+ })
+ return
+ }
+ dueDate := rawDueDate.UTC()
+ chore, err := h.choreRepo.GetChore(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+ chore.NextDueDate = &dueDate
+ chore.UpdatedBy = currentUser.ID
+ if err := h.choreRepo.UpsertChore(c, chore); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error updating due date",
+ })
+ return
+ }
+
+ c.JSON(200, gin.H{
+ "res": chore,
+ })
+}
+func (h *Handler) completeChore(c *gin.Context) {
+ type CompleteChoreReq struct {
+ Note string `json:"note"`
+ }
+ var req CompleteChoreReq
+ currentUser, ok := auth.CurrentUser(c)
+ if !ok {
+ c.JSON(500, gin.H{
+ "error": "Error getting current user",
+ })
+ return
+ }
+ completeChoreID := c.Param("id")
+ var completedDate time.Time
+ rawCompletedDate := c.Query("completedDate")
+ if rawCompletedDate == "" {
+ completedDate = time.Now().UTC()
+ } else {
+ var err error
+ completedDate, err = time.Parse(time.RFC3339, rawCompletedDate)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid date",
+ })
+ return
+ }
+ }
+
+ var additionalNotes *string
+ _ = c.ShouldBind(&req)
+
+ if req.Note != "" {
+ additionalNotes = &req.Note
+ }
+
+ id, err := strconv.Atoi(completeChoreID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+ chore, err := h.choreRepo.GetChore(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+
+ nextDueDate, err := scheduleNextDueDate(chore, completedDate)
+ if err != nil {
+ log.Printf("Error scheduling next due date: %s", err)
+ c.JSON(500, gin.H{
+ "error": "Error scheduling next due date",
+ })
+ return
+ }
+ choreHistory, err := h.choreRepo.GetChoreHistory(c, chore.ID)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore history",
+ })
+ return
+ }
+
+ nextAssignedTo, err := checkNextAssignee(chore, choreHistory, currentUser.ID)
+ if err != nil {
+ log.Printf("Error checking next assignee: %s", err)
+ c.JSON(500, gin.H{
+ "error": "Error checking next assignee",
+ })
+ return
+ }
+
+ if err := h.choreRepo.CompleteChore(c, chore, additionalNotes, currentUser.ID, nextDueDate, completedDate, nextAssignedTo); err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error completing chore",
+ })
+ return
+ }
+ updatedChore, err := h.choreRepo.GetChore(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore",
+ })
+ return
+ }
+ go func() {
+ h.notifier.SendChoreCompletion(c, chore, []*uModel.User{currentUser})
+ h.nPlanner.GenerateNotifications(c, updatedChore)
+ }()
+ c.JSON(200, gin.H{
+ "res": updatedChore,
+ })
+}
+
+func (h *Handler) GetChoreHistory(c *gin.Context) {
+ rawID := c.Param("id")
+ id, err := strconv.Atoi(rawID)
+ if err != nil {
+ c.JSON(400, gin.H{
+ "error": "Invalid ID",
+ })
+ return
+ }
+
+ choreHistory, err := h.choreRepo.GetChoreHistory(c, id)
+ if err != nil {
+ c.JSON(500, gin.H{
+ "error": "Error getting chore history",
+ })
+ return
+ }
+
+ c.JSON(200, gin.H{
+ "res": choreHistory,
+ })
+}
+
+func checkNextAssignee(chore *chModel.Chore, choresHistory []*chModel.ChoreHistory, performerID int) (int, error) {
+ // copy the history to avoid modifying the original:
+ history := make([]*chModel.ChoreHistory, len(choresHistory))
+ copy(history, choresHistory)
+
+ assigneesMap := map[int]bool{}
+ for _, assignee := range chore.Assignees {
+ assigneesMap[assignee.UserID] = true
+ }
+ var nextAssignee int
+ if len(history) == 0 {
+ // if there is no history, just assume the current operation as the first
+ history = append(history, &chModel.ChoreHistory{
+ AssignedTo: performerID,
+ })
+
+ }
+
+ switch chore.AssignStrategy {
+ case "least_assigned":
+ // find the assignee with the least number of chores
+ assigneeChores := map[int]int{}
+ for _, performer := range chore.Assignees {
+ assigneeChores[performer.UserID] = 0
+ }
+ for _, history := range history {
+ if ok := assigneesMap[history.AssignedTo]; !ok {
+ // calculate the number of chores assigned to each assignee
+ assigneeChores[history.AssignedTo]++
+ }
+ }
+
+ minChores := math.MaxInt64
+ for assignee, numChores := range assigneeChores {
+ // if this is the first assignee or if the number of
+ // chores assigned to this assignee is less than the current minimum
+ if numChores < minChores {
+ minChores = numChores
+ // set the next assignee to this assignee
+ nextAssignee = assignee
+ }
+ }
+ case "least_completed":
+ // find the assignee who has completed the least number of chores
+ assigneeChores := map[int]int{}
+ for _, performer := range chore.Assignees {
+ assigneeChores[performer.UserID] = 0
+ }
+ for _, history := range history {
+ // calculate the number of chores completed by each assignee
+ assigneeChores[history.CompletedBy]++
+ }
+
+ // max Int value
+ minChores := math.MaxInt64
+ for assignee, numChores := range assigneeChores {
+ // if this is the first assignee or if the number of
+ // chores completed by this assignee is less than the current minimum
+ if numChores < minChores {
+ minChores = numChores
+ // set the next assignee to this assignee
+ nextAssignee = assignee
+ }
+ }
+ case "random":
+ nextAssignee = chore.Assignees[rand.Intn(len(chore.Assignees))].UserID
+ case "keep_last_assigned":
+ // keep the last assignee
+ nextAssignee = history[len(history)-1].AssignedTo
+
+ default:
+ return chore.AssignedTo, fmt.Errorf("invalid assign strategy")
+
+ }
+ return nextAssignee, nil
+}
+
+func Routes(router *gin.Engine, h *Handler, auth *jwt.GinJWTMiddleware) {
+
+ choresRoutes := router.Group("chores")
+ choresRoutes.Use(auth.MiddlewareFunc())
+ {
+ choresRoutes.GET("/", h.getChores)
+ choresRoutes.PUT("/", h.editChore)
+ choresRoutes.POST("/", h.createChore)
+ choresRoutes.GET("/:id", h.getChore)
+ choresRoutes.GET("/:id/history", h.GetChoreHistory)
+ choresRoutes.POST("/:id/do", h.completeChore)
+ choresRoutes.POST("/:id/skip", h.skipChore)
+ choresRoutes.PUT("/:id/assignee", h.updateAssignee)
+ choresRoutes.PUT("/:id/dueDate", h.updateDueDate)
+ choresRoutes.DELETE("/:id", h.deleteChore)
+ }
+
+}
diff --git a/internal/chore/model/model.go b/internal/chore/model/model.go
new file mode 100644
index 0000000..4de7808
--- /dev/null
+++ b/internal/chore/model/model.go
@@ -0,0 +1,72 @@
+package model
+
+import (
+ "time"
+
+ tModel "donetick.com/core/internal/thing/model"
+)
+
+type Chore struct {
+ ID int `json:"id" gorm:"primary_key"`
+ Name string `json:"name" gorm:"column:name"` // Chore description
+ FrequencyType string `json:"frequencyType" gorm:"column:frequency_type"` // "daily", "weekly", "monthly", "yearly", "adaptive",or "custom"
+ Frequency int `json:"frequency" gorm:"column:frequency"` // Number of days, weeks, months, or years between chores
+ FrequencyMetadata *string `json:"frequencyMetadata" gorm:"column:frequency_meta"` // Additional frequency information
+ NextDueDate *time.Time `json:"nextDueDate" gorm:"column:next_due_date;index"` // When the chore is due
+ IsRolling bool `json:"isRolling" gorm:"column:is_rolling"` // Whether the chore is rolling
+ AssignedTo int `json:"assignedTo" gorm:"column:assigned_to"` // Who the chore is assigned to
+ Assignees []ChoreAssignees `json:"assignees" gorm:"foreignkey:ChoreID;references:ID"` // Assignees of the chore
+ AssignStrategy string `json:"assignStrategy" gorm:"column:assign_strategy"` // How the chore is assigned
+ IsActive bool `json:"isActive" gorm:"column:is_active"` // Whether the chore is active
+ Notification bool `json:"notification" gorm:"column:notification"` // Whether the chore has notification
+ NotificationMetadata *string `json:"notificationMetadata" gorm:"column:notification_meta"` // Additional notification information
+ Labels *string `json:"labels" gorm:"column:labels"` // Labels for the chore
+ CircleID int `json:"circleId" gorm:"column:circle_id;index"` // The circle this chore is in
+ CreatedAt time.Time `json:"createdAt" gorm:"column:created_at"` // When the chore was created
+ UpdatedAt time.Time `json:"updatedAt" gorm:"column:updated_at"` // When the chore was last updated
+ CreatedBy int `json:"createdBy" gorm:"column:created_by"` // Who created the chore
+ UpdatedBy int `json:"updatedBy" gorm:"column:updated_by"` // Who last updated the chore
+ ThingChore tModel.ThingChore `json:"thingChore" gorm:"foreignkey:chore_id;references:id;<-:false"` // ThingChore relationship
+}
+type ChoreAssignees struct {
+ ID int `json:"-" gorm:"primary_key"`
+ ChoreID int `json:"-" gorm:"column:chore_id;uniqueIndex:idx_chore_user"` // The chore this assignee is for
+ UserID int `json:"userId" gorm:"column:user_id;uniqueIndex:idx_chore_user"` // The user this assignee is for
+}
+type ChoreHistory struct {
+ ID int `json:"id" gorm:"primary_key"` // Unique identifier
+ ChoreID int `json:"choreId" gorm:"column:chore_id"` // The chore this history is for
+ CompletedAt time.Time `json:"completedAt" gorm:"column:completed_at"` // When the chore was completed
+ CompletedBy int `json:"completedBy" gorm:"column:completed_by"` // Who completed the chore
+ AssignedTo int `json:"assignedTo" gorm:"column:assigned_to"` // Who the chore was assigned to
+ Note *string `json:"notes" gorm:"column:notes"` // Notes about the chore
+ DueDate *time.Time `json:"dueDate" gorm:"column:due_date"` // When the chore was due
+}
+
+type FrequencyMetadata struct {
+ Days []*string `json:"days,omitempty"`
+ Months []*string `json:"months,omitempty"`
+ Unit *string `json:"unit,omitempty"`
+}
+
+type NotificationMetadata struct {
+ DueDate bool `json:"dueDate,omitempty"`
+ Completion bool `json:"completion,omitempty"`
+ Nagging bool `json:"nagging,omitempty"`
+ PreDue bool `json:"predue,omitempty"`
+}
+
+type Tag struct {
+ ID int `json:"-" gorm:"primary_key"`
+ Name string `json:"name" gorm:"column:name;unique"`
+}
+
+// type ChoreTag struct {
+// ChoreID int `json:"choreId" gorm:"primaryKey;autoIncrement:false"`
+// TagID int `json:"tagId" gorm:"primaryKey;autoIncrement:false"`
+// }
+
+// type CircleTag struct {
+// CircleID int `json:"circleId" gorm:"primaryKey;autoIncrement:false"`
+// TagID int `json:"tagId" gorm:"primaryKey;autoIncrement:false"`
+// }
diff --git a/internal/chore/repo/repository.go b/internal/chore/repo/repository.go
new file mode 100644
index 0000000..1ab0f0b
--- /dev/null
+++ b/internal/chore/repo/repository.go
@@ -0,0 +1,216 @@
+package chore
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ config "donetick.com/core/config"
+ chModel "donetick.com/core/internal/chore/model"
+ "gorm.io/gorm"
+)
+
+type ChoreRepository struct {
+ db *gorm.DB
+ dbType string
+}
+
+func NewChoreRepository(db *gorm.DB, cfg *config.Config) *ChoreRepository {
+ return &ChoreRepository{db: db, dbType: cfg.Database.Type}
+}
+
+func (r *ChoreRepository) UpsertChore(c context.Context, chore *chModel.Chore) error {
+ return r.db.WithContext(c).Model(&chore).Save(chore).Error
+}
+
+func (r *ChoreRepository) UpdateChores(c context.Context, chores []*chModel.Chore) error {
+ return r.db.WithContext(c).Save(&chores).Error
+}
+func (r *ChoreRepository) CreateChore(c context.Context, chore *chModel.Chore) (int, error) {
+ if err := r.db.WithContext(c).Create(chore).Error; err != nil {
+ return 0, err
+ }
+ return chore.ID, nil
+}
+
+func (r *ChoreRepository) GetChore(c context.Context, choreID int) (*chModel.Chore, error) {
+ var chore chModel.Chore
+ if err := r.db.Debug().WithContext(c).Model(&chModel.Chore{}).Preload("Assignees").Preload("ThingChore").First(&chore, choreID).Error; err != nil {
+ return nil, err
+ }
+ return &chore, nil
+}
+
+func (r *ChoreRepository) GetChores(c context.Context, circleID int, userID int) ([]*chModel.Chore, error) {
+ var chores []*chModel.Chore
+ // if err := r.db.WithContext(c).Preload("Assignees").Where("is_active = ?", true).Order("next_due_date asc").Find(&chores, "circle_id = ?", circleID).Error; err != nil {
+ if err := r.db.WithContext(c).Preload("Assignees").Joins("left join chore_assignees on chores.id = chore_assignees.chore_id").Where("chores.circle_id = ? AND (chores.created_by = ? OR chore_assignees.user_id = ?)", circleID, userID, userID).Group("chores.id").Order("next_due_date asc").Find(&chores, "circle_id = ?", circleID).Error; err != nil {
+ return nil, err
+ }
+ return chores, nil
+}
+func (r *ChoreRepository) DeleteChore(c context.Context, id int) error {
+ r.db.WithContext(c).Where("chore_id = ?", id).Delete(&chModel.ChoreAssignees{})
+ return r.db.WithContext(c).Delete(&chModel.Chore{}, id).Error
+}
+
+func (r *ChoreRepository) SoftDelete(c context.Context, id int, userID int) error {
+ return r.db.WithContext(c).Model(&chModel.Chore{}).Where("id = ?", id).Where("created_by = ? ", userID).Update("is_active", false).Error
+
+}
+
+func (r *ChoreRepository) IsChoreOwner(c context.Context, choreID int, userID int) error {
+ var chore chModel.Chore
+ err := r.db.WithContext(c).Model(&chModel.Chore{}).Where("id = ? AND created_by = ?", choreID, userID).First(&chore).Error
+ return err
+}
+
+// func (r *ChoreRepository) ListChores(circleID int) ([]*chModel.Chore, error) {
+// var chores []*Chore
+// if err := r.db.WithContext(c).Find(&chores).Where("is_active = ?", true).Order("next_due_date").Error; err != nil {
+// return nil, err
+// }
+// return chores, nil
+// }
+
+func (r *ChoreRepository) CompleteChore(c context.Context, chore *chModel.Chore, note *string, userID int, dueDate *time.Time, completedDate time.Time, nextAssignedTo int) error {
+ err := r.db.WithContext(c).Transaction(func(tx *gorm.DB) error {
+ ch := &chModel.ChoreHistory{
+ ChoreID: chore.ID,
+ CompletedAt: completedDate,
+ CompletedBy: userID,
+ AssignedTo: chore.AssignedTo,
+ DueDate: chore.NextDueDate,
+ Note: note,
+ }
+ if err := tx.Create(ch).Error; err != nil {
+ return err
+ }
+ updates := map[string]interface{}{}
+ updates["next_due_date"] = dueDate
+
+ if dueDate != nil {
+ updates["assigned_to"] = nextAssignedTo
+ } else {
+ updates["is_active"] = false
+ }
+ // Perform the update operation once, using the prepared updates map.
+ if err := tx.Model(&chModel.Chore{}).Where("id = ?", chore.ID).Updates(updates).Error; err != nil {
+ return err
+ }
+
+ return nil
+ })
+ return err
+}
+
+func (r *ChoreRepository) GetChoreHistory(c context.Context, choreID int) ([]*chModel.ChoreHistory, error) {
+ var histories []*chModel.ChoreHistory
+ if err := r.db.WithContext(c).Where("chore_id = ?", choreID).Order("completed_at desc").Find(&histories).Error; err != nil {
+ return nil, err
+ }
+ return histories, nil
+}
+
+func (r *ChoreRepository) UpdateChoreAssignees(c context.Context, assignees []*chModel.ChoreAssignees) error {
+ return r.db.WithContext(c).Save(&assignees).Error
+}
+
+func (r *ChoreRepository) DeleteChoreAssignees(c context.Context, choreAssignees []*chModel.ChoreAssignees) error {
+ return r.db.WithContext(c).Delete(&choreAssignees).Error
+}
+
+func (r *ChoreRepository) GetChoreAssignees(c context.Context, choreID int) ([]*chModel.ChoreAssignees, error) {
+ var assignees []*chModel.ChoreAssignees
+ if err := r.db.WithContext(c).Find(&assignees, "chore_id = ?", choreID).Error; err != nil {
+ return nil, err
+ }
+ return assignees, nil
+}
+
+func (r *ChoreRepository) RemoveChoreAssigneeByCircleID(c context.Context, userID int, circleID int) error {
+ return r.db.WithContext(c).Where("user_id = ? AND chore_id IN (SELECT id FROM chores WHERE circle_id = ? and created_by != ?)", userID, circleID, userID).Delete(&chModel.ChoreAssignees{}).Error
+}
+
+// func (r *ChoreRepository) getChoreDueToday(circleID int) ([]*chModel.Chore, error) {
+// var chores []*Chore
+// if err := r.db.WithContext(c).Where("next_due_date <= ?", time.Now().UTC()).Find(&chores).Error; err != nil {
+// return nil, err
+// }
+// return chores, nil
+// }
+
+func (r *ChoreRepository) GetAllActiveChores(c context.Context) ([]*chModel.Chore, error) {
+ var chores []*chModel.Chore
+ // query := r.db.WithContext(c).Table("chores").Joins("left join notifications n on n.chore_id = chores.id and n.scheduled_for < chores.next_due_date")
+ // if err := query.Where("chores.is_active = ? and chores.notification = ? and (n.is_sent = ? or n.is_sent is null)", true, true, false).Find(&chores).Error; err != nil {
+ // return nil, err
+ // }
+ return chores, nil
+}
+
+func (r *ChoreRepository) GetChoresForNotification(c context.Context) ([]*chModel.Chore, error) {
+ var chores []*chModel.Chore
+ query := r.db.WithContext(c).Table("chores").Joins("left join notifications n on n.chore_id = chores.id and n.scheduled_for = chores.next_due_date and n.type = 1")
+ if err := query.Where("chores.is_active = ? and chores.notification = ? and n.id is null", true, true).Find(&chores).Error; err != nil {
+ return nil, err
+ }
+ return chores, nil
+}
+
+// func (r *ChoreReposity) GetOverdueChoresForNotification(c context.Context, overdueDuration time.Duration, everyDuration time.Duration, untilDuration time.Duration) ([]*chModel.Chore, error) {
+// var chores []*chModel.Chore
+// query := r.db.Debug().WithContext(c).Table("chores").Select("chores.*, MAX(n.created_at) as max_notification_created_at").Joins("left join notifications n on n.chore_id = chores.id and n.scheduled_for = chores.next_due_date and n.type = 2")
+// if err := query.Where("chores.is_active = ? and chores.notification = ? and chores.next_due_date < ? and chores.next_due_date > ?", true, true, time.Now().Add(overdueDuration).UTC(), time.Now().Add(untilDuration).UTC()).Where(readJSONBooleanField(r.dbType, "chores.notification_meta", "nagging")).Having("MAX(n.created_at) is null or MAX(n.created_at) < ?", time.Now().Add(everyDuration).UTC()).Group("chores.id").Find(&chores).Error; err != nil {
+// return nil, err
+// }
+// return chores, nil
+// }
+
+func (r *ChoreRepository) GetOverdueChoresForNotification(c context.Context, overdueFor time.Duration, everyDuration time.Duration, untilDuration time.Duration) ([]*chModel.Chore, error) {
+ var chores []*chModel.Chore
+ now := time.Now().UTC()
+ overdueTime := now.Add(-overdueFor)
+ everyTime := now.Add(-everyDuration)
+ untilTime := now.Add(-untilDuration)
+
+ query := r.db.Debug().WithContext(c).
+ Table("chores").
+ Select("chores.*, MAX(n.created_at) as max_notification_created_at").
+ Joins("left join notifications n on n.chore_id = chores.id and n.type = 2").
+ Where("chores.is_active = ? AND chores.notification = ? AND chores.next_due_date < ? AND chores.next_due_date > ?", true, true, overdueTime, untilTime).
+ Where(readJSONBooleanField(r.dbType, "chores.notification_meta", "nagging")).
+ Group("chores.id").
+ Having("MAX(n.created_at) IS NULL OR MAX(n.created_at) < ?", everyTime)
+
+ if err := query.Find(&chores).Error; err != nil {
+ return nil, err
+ }
+
+ return chores, nil
+}
+
+// a predue notfication is a notification send before the due date in 6 hours, 3 hours :
+func (r *ChoreRepository) GetPreDueChoresForNotification(c context.Context, preDueDuration time.Duration, everyDuration time.Duration) ([]*chModel.Chore, error) {
+ var chores []*chModel.Chore
+ query := r.db.WithContext(c).Table("chores").Select("chores.*, MAX(n.created_at) as max_notification_created_at").Joins("left join notifications n on n.chore_id = chores.id and n.scheduled_for = chores.next_due_date and n.type = 3")
+ if err := query.Where("chores.is_active = ? and chores.notification = ? and chores.next_due_date > ? and chores.next_due_date < ?", true, true, time.Now().UTC(), time.Now().Add(everyDuration*2).UTC()).Where(readJSONBooleanField(r.dbType, "chores.notification_meta", "predue")).Having("MAX(n.created_at) is null or MAX(n.created_at) < ?", time.Now().Add(everyDuration).UTC()).Group("chores.id").Find(&chores).Error; err != nil {
+ return nil, err
+ }
+ return chores, nil
+}
+
+func readJSONBooleanField(dbType string, columnName string, fieldName string) string {
+ if dbType == "postgres" {
+ return fmt.Sprintf("(%s::json->>'%s')::boolean", columnName, fieldName)
+ }
+ return fmt.Sprintf("JSON_EXTRACT(%s, '$.%s')", columnName, fieldName)
+}
+
+func (r *ChoreRepository) SetDueDate(c context.Context, choreID int, dueDate time.Time) error {
+ return r.db.WithContext(c).Model(&chModel.Chore{}).Where("id = ?", choreID).Update("next_due_date", dueDate).Error
+}
+
+func (r *ChoreRepository) SetDueDateIfNotExisted(c context.Context, choreID int, dueDate time.Time) error {
+ return r.db.WithContext(c).Model(&chModel.Chore{}).Where("id = ? and next_due_date is null", choreID).Update("next_due_date", dueDate).Error
+}
diff --git a/internal/chore/scheduler.go b/internal/chore/scheduler.go
new file mode 100644
index 0000000..55cdf01
--- /dev/null
+++ b/internal/chore/scheduler.go
@@ -0,0 +1,145 @@
+package chore
+
+import (
+ "encoding/json"
+ "fmt"
+ "math/rand"
+ "strings"
+ "time"
+
+ chModel "donetick.com/core/internal/chore/model"
+)
+
+func scheduleNextDueDate(chore *chModel.Chore, completedDate time.Time) (*time.Time, error) {
+ // if Chore is rolling then the next due date calculated from the completed date, otherwise it's calculated from the due date
+ var nextDueDate time.Time
+ var baseDate time.Time
+ var frequencyMetadata chModel.FrequencyMetadata
+ err := json.Unmarshal([]byte(*chore.FrequencyMetadata), &frequencyMetadata)
+ if err != nil {
+ return nil, fmt.Errorf("error unmarshalling frequency metadata")
+ }
+ if chore.FrequencyType == "once" {
+ return nil, nil
+ }
+ if chore.NextDueDate != nil {
+ // no due date set, use the current date
+
+ baseDate = chore.NextDueDate.UTC()
+ } else {
+ baseDate = completedDate.UTC()
+ }
+ if chore.IsRolling && chore.NextDueDate.Before(completedDate) {
+ // we need to check if chore due date is before the completed date to handle this senario:
+ // if user trying to complete chore due in future (multiple time for insance) due date will be calculated
+ // from the last completed date and due date change only in seconds.
+ // this make sure that the due date is always in future if the chore is rolling
+
+ baseDate = completedDate.UTC()
+ }
+
+ if chore.FrequencyType == "daily" {
+ nextDueDate = baseDate.AddDate(0, 0, 1)
+ } else if chore.FrequencyType == "weekly" {
+ nextDueDate = baseDate.AddDate(0, 0, 7)
+ } else if chore.FrequencyType == "monthly" {
+ nextDueDate = baseDate.AddDate(0, 1, 0)
+ } else if chore.FrequencyType == "yearly" {
+ nextDueDate = baseDate.AddDate(1, 0, 0)
+ } else if chore.FrequencyType == "adaptive" {
+ // TODO: calculate next due date based on the history of the chore
+ // calculate the difference between the due date and now in days:
+ diff := completedDate.UTC().Sub(chore.NextDueDate.UTC())
+ nextDueDate = completedDate.UTC().Add(diff)
+ } else if chore.FrequencyType == "once" {
+ // if the chore is a one-time chore, then the next due date is nil
+ } else if chore.FrequencyType == "interval" {
+ // calculate the difference between the due date and now in days:
+ if *frequencyMetadata.Unit == "hours" {
+ nextDueDate = baseDate.UTC().Add(time.Hour * time.Duration(chore.Frequency))
+ } else if *frequencyMetadata.Unit == "days" {
+ nextDueDate = baseDate.UTC().AddDate(0, 0, chore.Frequency)
+ } else if *frequencyMetadata.Unit == "weeks" {
+ nextDueDate = baseDate.UTC().AddDate(0, 0, chore.Frequency*7)
+ } else if *frequencyMetadata.Unit == "months" {
+ nextDueDate = baseDate.UTC().AddDate(0, chore.Frequency, 0)
+ } else if *frequencyMetadata.Unit == "years" {
+ nextDueDate = baseDate.UTC().AddDate(chore.Frequency, 0, 0)
+ } else {
+
+ return nil, fmt.Errorf("invalid frequency unit, cannot calculate next due date")
+ }
+ } else if chore.FrequencyType == "days_of_the_week" {
+ // TODO : this logic is bad, need to be refactored and be better.
+ // coding at night is almost always bad idea.
+ // calculate the difference between the due date and now in days:
+ var frequencyMetadata chModel.FrequencyMetadata
+ err := json.Unmarshal([]byte(*chore.FrequencyMetadata), &frequencyMetadata)
+ if err != nil {
+
+ return nil, fmt.Errorf("error unmarshalling frequency metadata")
+ }
+ //we can only assign to days of the week that part of the frequency metadata.days
+ //it's array of days of the week, for example ["monday", "tuesday", "wednesday"]
+
+ // we need to find the next day of the week in the frequency metadata.days that we can schedule
+ // if this the last or there is only one. will use same otherwise find the next one:
+
+ // find the index of the chore day in the frequency metadata.days
+ // loop for next 7 days from the base, if the day in the frequency metadata.days then we can schedule it:
+ for i := 1; i <= 7; i++ {
+ nextDueDate = baseDate.AddDate(0, 0, i)
+ nextDay := strings.ToLower(nextDueDate.Weekday().String())
+ for _, day := range frequencyMetadata.Days {
+ if strings.ToLower(*day) == nextDay {
+ nextDate := nextDueDate.UTC()
+ return &nextDate, nil
+ }
+ }
+ }
+ } else if chore.FrequencyType == "day_of_the_month" {
+ var frequencyMetadata chModel.FrequencyMetadata
+ err := json.Unmarshal([]byte(*chore.FrequencyMetadata), &frequencyMetadata)
+ if err != nil {
+
+ return nil, fmt.Errorf("error unmarshalling frequency metadata")
+ }
+
+ for i := 1; i <= 12; i++ {
+ nextDueDate = baseDate.AddDate(0, i, 0)
+ // set the date to the first day of the month:
+ nextDueDate = time.Date(nextDueDate.Year(), nextDueDate.Month(), chore.Frequency, nextDueDate.Hour(), nextDueDate.Minute(), 0, 0, nextDueDate.Location())
+ nextMonth := strings.ToLower(nextDueDate.Month().String())
+ for _, month := range frequencyMetadata.Months {
+ if *month == nextMonth {
+ nextDate := nextDueDate.UTC()
+ return &nextDate, nil
+ }
+ }
+ }
+ } else if chore.FrequencyType == "no_repeat" {
+ return nil, nil
+ } else if chore.FrequencyType == "trigger" {
+ // if the chore is a trigger chore, then the next due date is nil
+ return nil, nil
+ } else {
+ return nil, fmt.Errorf("invalid frequency type, cannot calculate next due date")
+ }
+ return &nextDueDate, nil
+
+}
+
+func RemoveAssigneeAndReassign(chore *chModel.Chore, userID int) {
+ for i, assignee := range chore.Assignees {
+ if assignee.UserID == userID {
+ chore.Assignees = append(chore.Assignees[:i], chore.Assignees[i+1:]...)
+ break
+ }
+ }
+ if len(chore.Assignees) == 0 {
+ chore.AssignedTo = chore.CreatedBy
+ } else {
+ chore.AssignedTo = chore.Assignees[rand.Intn(len(chore.Assignees))].UserID
+ }
+ chore.UpdatedAt = time.Now()
+}
generated by cgit (git 2.34.1) at 2024-10-16 16:21:17 +0000