Refactored getting more task infos

pkg/models/label_task.go

@@ -306,7 +306,7 @@ type LabelTaskBulk struct {
 // @Failure 500 {object} models.Message "Internal error"
 // @Router /tasks/{taskID}/labels/bulk [post]
 func (ltb *LabelTaskBulk) Create(a web.Auth) (err error) {
-	task, err := GetListTaskByID(ltb.TaskID)
+	task, err := GetTaskByID(ltb.TaskID)
 	if err != nil {
 		return
 	}

pkg/models/list_task_assignees.go

@@ -260,7 +260,7 @@ type BulkAssignees struct {
 // @Failure 500 {object} models.Message "Internal error"
 // @Router /tasks/{taskID}/assignees/bulk [post]
 func (ba *BulkAssignees) Create(a web.Auth) (err error) {
-	task, err := GetListTaskByID(ba.TaskID) // We need to use the full method here because we need all current assignees.
+	task, err := GetTaskByID(ba.TaskID) // We need to use the full method here because we need all current assignees.
 	if err != nil {
 		return
 	}

pkg/models/list_tasks.go

@@ -93,74 +93,7 @@ func GetTasksByListID(listID int64) (tasks []*ListTask, err error) {
 		return
 	}
 
-	// No need to iterate over users and stuff if the list doesn't has tasks
-	if len(taskMap) == 0 {
-		return
-	}
-
-	// Get all users & task ids and put them into the array
-	var userIDs []int64
-	var taskIDs []int64
-	for _, i := range taskMap {
-		taskIDs = append(taskIDs, i.ID)
-		userIDs = append(userIDs, i.CreatedByID)
-	}
-
-	// Get all assignees
-	taskAssignees, err := getRawTaskAssigneesForTasks(taskIDs)
-	if err != nil {
-		return
-	}
-	// Put the assignees in the task map
-	for _, a := range taskAssignees {
-		if a != nil {
-			taskMap[a.TaskID].Assignees = append(taskMap[a.TaskID].Assignees, &a.User)
-		}
-	}
-
-	// Get all labels for the tasks
-	labels, err := getLabelsByTaskIDs(&LabelByTaskIDsOptions{TaskIDs: taskIDs})
-	if err != nil {
-		return
-	}
-	for _, l := range labels {
-		if l != nil {
-			taskMap[l.TaskID].Labels = append(taskMap[l.TaskID].Labels, &l.Label)
-		}
-	}
-
-	users := make(map[int64]*User)
-	err = x.In("id", userIDs).Find(&users)
-	if err != nil {
-		return
-	}
-
-	// Add all user objects to the appropriate tasks
-	for _, task := range taskMap {
-
-		// Make created by user objects
-		taskMap[task.ID].CreatedBy = *users[task.CreatedByID]
-
-		// Reorder all subtasks
-		if task.ParentTaskID != 0 {
-			taskMap[task.ParentTaskID].Subtasks = append(taskMap[task.ParentTaskID].Subtasks, task)
-			delete(taskMap, task.ID)
-		}
-	}
-
-	// make a complete slice from the map
-	tasks = []*ListTask{}
-	for _, t := range taskMap {
-		tasks = append(tasks, t)
-	}
-
-	// Sort the output. In Go, contents on a map are put on that map in no particular order (saved on heap).
-	// Because of this, tasks are not sorted anymore in the output, this leads to confiusion.
-	// To avoid all this, we need to sort the slice afterwards
-	sort.Slice(tasks, func(i, j int) bool {
-		return tasks[i].ID < tasks[j].ID
-	})
-
+	tasks, err = addMoreInfoToTasks(taskMap)
 	return
 }
 
@@ -187,8 +120,8 @@ func GetTaskSimple(t *ListTask) (task ListTask, err error) {
 	return
 }
 
-// GetListTaskByID returns all tasks a list has
-func GetListTaskByID(listTaskID int64) (listTask ListTask, err error) {
+// GetTaskByID returns all tasks a list has
+func GetTaskByID(listTaskID int64) (listTask ListTask, err error) {
 	listTask, err = GetTaskByIDSimple(listTaskID)
 	if err != nil {
 		return
@@ -233,37 +166,89 @@ func (bt *BulkTask) GetTasksByIDs() (err error) {
 		}
 	}
 
-	err = x.In("id", bt.IDs).Find(&bt.Tasks)
+	taskMap := make(map[int64]*ListTask, len(bt.Tasks))
+	err = x.In("id", bt.IDs).Find(&taskMap)
 	if err != nil {
-		return err
+		return
 	}
 
-	// We use a map, to avoid looping over two slices at once
-	var usermapids = make(map[int64]bool) // Bool ist just something, doesn't acutually matter
-	for _, list := range bt.Tasks {
-		usermapids[list.CreatedByID] = true
+	bt.Tasks, err = addMoreInfoToTasks(taskMap)
+	return
+}
+
+// This function takes a map with pointers and returns a slice with pointers to tasks
+// It adds more stuff like assignees/labels/etc to a bunch of tasks
+func addMoreInfoToTasks(taskMap map[int64]*ListTask) (tasks []*ListTask, err error) {
+
+	// No need to iterate over users and stuff if the list doesn't has tasks
+	if len(taskMap) == 0 {
+		return
 	}
 
-	// Make a slice from the map
-	var userids []int64
-	for uid := range usermapids {
-		userids = append(userids, uid)
+	// Get all users & task ids and put them into the array
+	var userIDs []int64
+	var taskIDs []int64
+	for _, i := range taskMap {
+		taskIDs = append(taskIDs, i.ID)
+		userIDs = append(userIDs, i.CreatedByID)
 	}
 
-	// Get all users for the tasks
-	var users []*User
-	err = x.In("id", userids).Find(&users)
+	// Get all assignees
+	taskAssignees, err := getRawTaskAssigneesForTasks(taskIDs)
 	if err != nil {
-		return err
+		return
 	}
-
-	for in, task := range bt.Tasks {
-		for _, u := range users {
-			if task.CreatedByID == u.ID {
-				bt.Tasks[in].CreatedBy = *u
-			}
+	// Put the assignees in the task map
+	for _, a := range taskAssignees {
+		if a != nil {
+			taskMap[a.TaskID].Assignees = append(taskMap[a.TaskID].Assignees, &a.User)
 		}
 	}
 
+	// Get all labels for all the tasks
+	labels, err := getLabelsByTaskIDs(&LabelByTaskIDsOptions{TaskIDs: taskIDs})
+	if err != nil {
+		return
+	}
+	for _, l := range labels {
+		if l != nil {
+			taskMap[l.TaskID].Labels = append(taskMap[l.TaskID].Labels, &l.Label)
+		}
+	}
+
+	// Get all users of a task
+	// aka the ones who created a task
+	users := make(map[int64]*User)
+	err = x.In("id", userIDs).Find(&users)
+	if err != nil {
+		return
+	}
+
+	// Add all user objects to the appropriate tasks
+	for _, task := range taskMap {
+
+		// Make created by user objects
+		taskMap[task.ID].CreatedBy = *users[task.CreatedByID]
+
+		// Reorder all subtasks
+		if task.ParentTaskID != 0 {
+			taskMap[task.ParentTaskID].Subtasks = append(taskMap[task.ParentTaskID].Subtasks, task)
+			delete(taskMap, task.ID)
+		}
+	}
+
+	// make a complete slice from the map
+	tasks = []*ListTask{}
+	for _, t := range taskMap {
+		tasks = append(tasks, t)
+	}
+
+	// Sort the output. In Go, contents on a map are put on that map in no particular order.
+	// Because of this, tasks are not sorted anymore in the output, this leads to confiusion.
+	// To avoid all this, we need to sort the slice afterwards
+	sort.Slice(tasks, func(i, j int) bool {
+		return tasks[i].ID < tasks[j].ID
+	})
+
 	return
 }

pkg/models/list_tasks_create_update.go

@@ -100,7 +100,7 @@ func (t *ListTask) Create(a web.Auth) (err error) {
 // @Router /tasks/{id} [post]
 func (t *ListTask) Update() (err error) {
 	// Check if the task exists
-	ot, err := GetListTaskByID(t.ID)
+	ot, err := GetTaskByID(t.ID)
 	if err != nil {
 		return
 	}

pkg/models/list_tasks_delete.go

@@ -36,7 +36,7 @@ import (
 func (t *ListTask) Delete() (err error) {
 
 	// Check if it exists
-	_, err = GetListTaskByID(t.ID)
+	_, err = GetTaskByID(t.ID)
 	if err != nil {
 		return
 	}

pkg/models/list_tasks_test.go

@@ -49,7 +49,7 @@ func TestListTask_Create(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Check if it was updated
-	li, err := GetListTaskByID(listtask.ID)
+	li, err := GetTaskByID(listtask.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, li.Text, "Test34")