vikunja-api/pkg/models/list_tasks.go

199 lines
5.3 KiB
Go
Raw Normal View History

2018-11-26 21:17:33 +01:00
// Vikunja is a todo-list application to facilitate your life.
// Copyright 2018 Vikunja and contributors. All rights reserved.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
2018-06-10 15:55:56 +02:00
package models
2018-12-02 01:49:30 +01:00
import (
"code.vikunja.io/web"
2018-12-19 20:14:48 +01:00
"sort"
2018-12-02 01:49:30 +01:00
)
2018-12-01 00:26:56 +01:00
2018-08-30 08:09:17 +02:00
// ListTask represents an task in a todolist
type ListTask struct {
2018-11-21 16:03:47 +01:00
ID int64 `xorm:"int(11) autoincr not null unique pk" json:"id" param:"listtask"`
2018-11-24 13:44:40 +01:00
Text string `xorm:"varchar(250)" json:"text" valid:"runelength(3|250)"`
2018-11-21 16:03:47 +01:00
Description string `xorm:"varchar(250)" json:"description" valid:"runelength(0|250)"`
Done bool `xorm:"INDEX" json:"done"`
DueDateUnix int64 `xorm:"int(11) INDEX" json:"dueDate"`
RemindersUnix []int64 `xorm:"JSON TEXT" json:"reminderDates"`
CreatedByID int64 `xorm:"int(11)" json:"-"` // ID of the user who put that task on the list
ListID int64 `xorm:"int(11) INDEX" json:"listID" param:"list"`
2018-11-26 21:24:00 +01:00
RepeatAfter int64 `xorm:"int(11) INDEX" json:"repeatAfter"`
2018-12-01 03:00:57 +01:00
ParentTaskID int64 `xorm:"int(11) INDEX" json:"parentTaskID"`
2018-12-02 01:49:30 +01:00
Priority int64 `xorm:"int(11)" json:"priority"`
2018-12-22 16:45:16 +01:00
StartDateUnix int64 `xorm:"int(11) INDEX" json:"startDate"`
EndDateUnix int64 `xorm:"int(11) INDEX" json:"endDate"`
2018-12-01 03:00:57 +01:00
2018-12-22 19:06:14 +01:00
Sorting string `xorm:"-" json:"-" param:"sort"` // Parameter to sort by
StartDateSortUnix int64 `xorm:"-" json:"-" param:"startdatefilter"`
EndDateSortUnix int64 `xorm:"-" json:"-" param:"enddatefilter"`
2018-12-01 03:00:57 +01:00
Subtasks []*ListTask `xorm:"-" json:"subtasks"`
2018-11-17 00:17:37 +01:00
2018-11-24 13:44:40 +01:00
Created int64 `xorm:"created" json:"created"`
Updated int64 `xorm:"updated" json:"updated"`
2018-06-10 15:55:56 +02:00
2018-11-25 22:38:50 +01:00
CreatedBy User `xorm:"-" json:"createdBy" valid:"-"`
2018-12-01 00:26:56 +01:00
web.CRUDable `xorm:"-" json:"-"`
web.Rights `xorm:"-" json:"-"`
2018-06-10 15:55:56 +02:00
}
2018-08-30 08:09:17 +02:00
// TableName returns the table name for listtasks
func (ListTask) TableName() string {
return "tasks"
2018-06-10 15:55:56 +02:00
}
2018-08-30 08:09:17 +02:00
// GetTasksByListID gets all todotasks for a list
func GetTasksByListID(listID int64) (tasks []*ListTask, err error) {
err = x.Where("list_id = ?", listID).Find(&tasks)
if err != nil {
return
}
2018-08-30 08:09:17 +02:00
// No need to iterate over users if the list doesn't has tasks
if len(tasks) == 0 {
2018-07-09 19:49:27 +02:00
return
}
2018-12-01 03:00:57 +01:00
// make a map so we can put in subtasks more easily
2018-12-19 20:14:48 +01:00
taskMap := make(map[int64]*ListTask, len(tasks))
2018-12-01 03:00:57 +01:00
// Get all users and put them into the array
var userIDs []int64
2018-08-30 08:09:17 +02:00
for _, i := range tasks {
found := false
for _, u := range userIDs {
if i.CreatedByID == u {
found = true
break
}
}
if !found {
userIDs = append(userIDs, i.CreatedByID)
}
2018-12-01 03:00:57 +01:00
taskMap[i.ID] = i
}
var users []User
err = x.In("id", userIDs).Find(&users)
if err != nil {
return
}
2018-12-01 03:00:57 +01:00
// Add all user objects to the appropriate tasks
for _, task := range taskMap {
// Make created by user objects
2018-10-31 13:42:38 +01:00
for _, u := range users {
if task.CreatedByID == u.ID {
2018-12-01 03:00:57 +01:00
taskMap[task.ID].CreatedBy = u
break
}
}
2018-12-01 03:00:57 +01:00
// 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)
}
2018-12-19 20:14:48 +01:00
// 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
})
2018-06-10 15:55:56 +02:00
return
}
2018-08-30 08:09:17 +02:00
// GetListTaskByID returns all tasks a list has
func GetListTaskByID(listTaskID int64) (listTask ListTask, err error) {
if listTaskID < 1 {
return ListTask{}, ErrListTaskDoesNotExist{listTaskID}
}
2018-08-30 08:09:17 +02:00
exists, err := x.ID(listTaskID).Get(&listTask)
if err != nil {
2018-08-30 08:09:17 +02:00
return ListTask{}, err
}
if !exists {
2018-08-30 08:09:17 +02:00
return ListTask{}, ErrListTaskDoesNotExist{listTaskID}
}
2018-10-31 13:42:38 +01:00
u, err := GetUserByID(listTask.CreatedByID)
2018-06-12 19:57:38 +02:00
if err != nil {
return
}
2018-10-31 13:42:38 +01:00
listTask.CreatedBy = u
2018-06-12 19:57:38 +02:00
return
}
2018-12-28 22:49:46 +01:00
// GetTasksByIDs returns all tasks for a list of ids
func (bt *BulkTask) GetTasksByIDs() (err error) {
for _, id := range bt.IDs {
if id < 1 {
return ErrListTaskDoesNotExist{id}
}
}
err = x.In("id", bt.IDs).Find(&bt.Tasks)
if err != nil {
return err
}
// 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
}
// Make a slice from the map
var userids []int64
for uid := range usermapids {
userids = append(userids, uid)
}
// Get all users for the tasks
var users []*User
err = x.In("id", userids).Find(&users)
if err != nil {
return err
}
for in, task := range bt.Tasks {
for _, u := range users {
if task.CreatedByID == u.ID {
bt.Tasks[in].CreatedBy = *u
}
}
}
return
}