.drone.yml

@@ -28,7 +28,7 @@ steps:
       - make build-debug
 
   - name: test
-    image: vikunja/flutter-build
+    image: cirrusci/flutter:stable
     pull: true
     commands:
       - flutter packages get

lib/api/label_task.dart

@@ -0,0 +1,29 @@
+import 'package:vikunja_app/api/client.dart';
+import 'package:vikunja_app/api/service.dart';
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/models/labelTask.dart';
+import 'package:vikunja_app/service/services.dart';
+
+class LabelTaskAPIService extends APIService implements LabelTaskService {
+  LabelTaskAPIService(Client client) : super(client);
+
+  @override
+  Future<Label> create(LabelTask lt) async {
+    return client
+        .put('/tasks/${lt.task.id}/labels', body: lt.toJSON())
+        .then((result) => Label.fromJson(result));
+  }
+
+  @override
+  Future<Label> delete(LabelTask lt) async {
+    return client.delete('/tasks/${lt.task.id}/labels/${lt.label.id}');
+  }
+
+  @override
+  Future<List<Label>> getAll(LabelTask lt, {String query}) async {
+    String params =
+        query == '' ? null : '?s=' + Uri.encodeQueryComponent(query);
+    return client.get('/tasks/${lt.task.id}/labels$params').then(
+        (label) => convertList(label, (result) => Label.fromJson(result)));
+  }
+}

lib/api/label_task_bulk.dart

@@ -0,0 +1,20 @@
+import 'package:vikunja_app/api/client.dart';
+import 'package:vikunja_app/api/service.dart';
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/models/labelTaskBulk.dart';
+import 'package:vikunja_app/models/task.dart';
+import 'package:vikunja_app/service/services.dart';
+
+class LabelTaskBulkAPIService extends APIService
+    implements LabelTaskBulkService {
+  LabelTaskBulkAPIService(Client client) : super(client);
+
+  @override
+  Future<List<Label>> update(Task task, List<Label> labels) {
+    return client
+        .post('/tasks/${task.id}/labels/bulk',
+            body: LabelTaskBulk(labels: labels).toJSON())
+        .then((map) =>
+            convertList(map['labels'], (result) => Label.fromJson(result)));
+  }
+}

lib/api/labels.dart

@@ -0,0 +1,40 @@
+import 'package:vikunja_app/api/client.dart';
+import 'package:vikunja_app/api/service.dart';
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/service/services.dart';
+
+class LabelAPIService extends APIService implements LabelService {
+  LabelAPIService(Client client) : super(client);
+
+  @override
+  Future<Label> create(Label label) {
+    return client
+        .put('/labels', body: label.toJSON())
+        .then((result) => Label.fromJson(result));
+  }
+
+  @override
+  Future<Label> delete(Label label) {
+    return client.delete('/labels/${label.id}');
+  }
+
+  @override
+  Future<Label> get(int labelID) {
+    return client.get('/labels/$labelID').then((map) => Label.fromJson(map));
+  }
+
+  @override
+  Future<List<Label>> getAll({String query}) {
+    String params =
+        query == '' ? null : '?s=' + Uri.encodeQueryComponent(query);
+    return client.get('/labels$params').then(
+        (label) => convertList(label, (result) => Label.fromJson(result)));
+  }
+
+  @override
+  Future<Label> update(Label label) {
+    return client
+        .post('/labels/${label.id}', body: label)
+        .then((map) => Label.fromJson(map));
+  }
+}

lib/components/TaskTile.dart

@@ -7,26 +7,28 @@ import 'package:vikunja_app/models/task.dart';
 class TaskTile extends StatefulWidget {
   final Task task;
   final VoidCallback onEdit;
+  final ValueSetter<bool> onMarkedAsDone;
   final bool loading;
 
   const TaskTile(
-      {Key key, @required this.task, this.onEdit, this.loading = false})
+      {Key key,
+      @required this.task,
+      this.onEdit,
+      this.loading = false,
+      this.onMarkedAsDone})
       : assert(task != null),
         super(key: key);
 
   @override
   TaskTileState createState() {
-    return new TaskTileState(this.task, this.loading);
+    return new TaskTileState(this.loading);
   }
 }
 
 class TaskTileState extends State<TaskTile> {
   bool _loading;
-  Task _currentTask;
 
-  TaskTileState(this._currentTask, this._loading)
-      : assert(_currentTask != null),
-        assert(_loading != null);
+  TaskTileState(this._loading) : assert(_loading != null);
 
   @override
   Widget build(BuildContext context) {
@@ -41,29 +43,30 @@ class TaskTileState extends State<TaskTile> {
                 strokeWidth: 2.0,
               )),
         ),
-        title: Text(_currentTask.text),
+        title: Text(widget.task.text),
         subtitle:
-            _currentTask.description == null || _currentTask.description.isEmpty
+            widget.task.description == null || widget.task.description.isEmpty
                 ? null
-                : Text(_currentTask.description),
+                : Text(widget.task.description),
         trailing: IconButton(
-            icon: Icon(Icons.settings),
-            onPressed: () {
-              null; // TODO: implement edit task
-            }),
+          icon: Icon(Icons.settings),
+          onPressed: () => widget.onEdit,
+        ),
       );
     }
     return CheckboxListTile(
-      title: Text(_currentTask.text),
+      title: Text(widget.task.text),
       controlAffinity: ListTileControlAffinity.leading,
-      value: _currentTask.done ?? false,
+      value: widget.task.done ?? false,
       subtitle:
-          _currentTask.description == null || _currentTask.description.isEmpty
+          widget.task.description == null || widget.task.description.isEmpty
               ? null
-              : Text(_currentTask.description),
-      secondary:
-          IconButton(icon: Icon(Icons.settings), onPressed: widget.onEdit),
-      onChanged: _change,
+              : Text(widget.task.description),
+      secondary: IconButton(
+        icon: Icon(Icons.settings),
+        onPressed: widget.onEdit,
+      ),
+      onChanged: widget.onMarkedAsDone,
     );
   }
 
@@ -71,9 +74,9 @@ class TaskTileState extends State<TaskTile> {
     setState(() {
       this._loading = true;
     });
-    Task newTask = await _updateTask(_currentTask, value);
+    Task newTask = await _updateTask(widget.task, value);
     setState(() {
-      this._currentTask = newTask;
+      //this.widget.task = newTask;
       this._loading = false;
     });
   }
@@ -83,9 +86,6 @@ class TaskTileState extends State<TaskTile> {
     return VikunjaGlobal.of(context).taskService.update(Task(
           id: task.id,
           done: checked,
-          text: task.text,
-          description: task.description,
-          owner: null,
         ));
   }
 }

lib/components/datetimePicker.dart

@@ -0,0 +1,45 @@
+import 'package:datetime_picker_formfield/datetime_picker_formfield.dart';
+import 'package:flutter/material.dart';
+
+import 'package:vikunja_app/theme/constants.dart';
+
+class VikunjaDateTimePicker extends StatelessWidget {
+  final String label;
+  final Function onSaved;
+  final Function onChanged;
+  final DateTime initialValue;
+  final EdgeInsetsGeometry padding;
+  final Icon icon;
+  final InputBorder border;
+
+  const VikunjaDateTimePicker({
+    Key key,
+    @required this.label,
+    this.onSaved,
+    this.onChanged,
+    this.initialValue,
+    this.padding = const EdgeInsets.symmetric(vertical: 10.0),
+    this.icon = const Icon(Icons.date_range),
+    this.border = InputBorder.none,
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return DateTimePickerFormField(
+      dateOnly: false,
+      editable:
+          false, // Otherwise editing the date is not possible, this setting affects the underlying text field.
+      initialValue: initialValue == DateTime.fromMillisecondsSinceEpoch(0)
+          ? null
+          : initialValue,
+      format: vDateFormatLong,
+      decoration: InputDecoration(
+        labelText: label,
+        border: border,
+        icon: icon,
+      ),
+      onSaved: onSaved,
+      onChanged: onChanged,
+    );
+  }
+}

lib/components/label.dart

@@ -0,0 +1,52 @@
+import 'package:flutter/material.dart';
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/theme/constants.dart';
+
+class LabelComponent extends StatefulWidget {
+  final Label label;
+  final VoidCallback onDelete;
+
+  const LabelComponent({Key key, @required this.label, this.onDelete})
+      : super(key: key);
+
+  @override
+  State<StatefulWidget> createState() {
+    return new LabelComponentState();
+  }
+}
+
+class LabelComponentState extends State<LabelComponent> {
+  @override
+  Widget build(BuildContext context) {
+    Color backgroundColor = widget.label.color ?? vLabelDefaultColor;
+    Color textColor =
+        backgroundColor.computeLuminance() > 0.5 ? vLabelDark : vLabelLight;
+
+    return Chip(
+      label: Text(
+        widget.label.title,
+        style: TextStyle(
+          color: textColor,
+        ),
+      ),
+      backgroundColor: backgroundColor,
+      shape: RoundedRectangleBorder(
+        borderRadius: BorderRadius.all(Radius.circular(3)),
+      ),
+      onDeleted: widget.onDelete,
+      deleteIconColor: textColor,
+      deleteIcon: Container(
+        padding: EdgeInsets.all(3),
+        decoration: BoxDecoration(
+          color: Color.fromARGB(50, 0, 0, 0),
+          shape: BoxShape.circle,
+        ),
+        child: Icon(
+          Icons.close,
+          color: textColor,
+          size: 15,
+        ),
+      ),
+    );
+  }
+}

lib/global.dart

@@ -1,6 +1,9 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 import 'package:vikunja_app/api/client.dart';
+import 'package:vikunja_app/api/label_task.dart';
+import 'package:vikunja_app/api/label_task_bulk.dart';
+import 'package:vikunja_app/api/labels.dart';
 import 'package:vikunja_app/api/list_implementation.dart';
 import 'package:vikunja_app/api/namespace_implementation.dart';
 import 'package:vikunja_app/api/task_implementation.dart';
@@ -46,6 +49,13 @@ class VikunjaGlobalState extends State<VikunjaGlobal> {
 
   ListService get listService => new ListAPIService(client);
 
+  LabelService get labelService => new LabelAPIService(client);
+
+  LabelTaskService get labelTaskService => new LabelTaskAPIService(client);
+
+  LabelTaskBulkAPIService get labelTaskBulkService =>
+      new LabelTaskBulkAPIService(client);
+
   @override
   void initState() {
     super.initState();

lib/models/label.dart

@@ -0,0 +1,43 @@
+import 'dart:ui';
+
+import 'package:meta/meta.dart';
+import 'package:vikunja_app/models/user.dart';
+
+class Label {
+  final int id;
+  final String title, description;
+  final DateTime created, updated;
+  final User createdBy;
+  final Color color;
+
+  Label(
+      {this.id,
+      this.title,
+      this.description,
+      this.color,
+      this.created,
+      this.updated,
+      this.createdBy});
+
+  Label.fromJson(Map<String, dynamic> json)
+      : id = json['id'],
+        title = json['title'],
+        description = json['description'],
+        color = json['hex_color'] == ''
+            ? null
+            : new Color(int.parse(json['hex_color'], radix: 16) + 0xFF000000),
+        updated = DateTime.fromMillisecondsSinceEpoch(json['updated']),
+        created = DateTime.fromMillisecondsSinceEpoch(json['created']),
+        createdBy = User.fromJson(json['created_by']);
+
+  toJSON() => {
+        'id': id,
+        'title': title,
+        'description': description,
+        'hex_color':
+            color?.value?.toRadixString(16)?.padLeft(8, '0')?.substring(2),
+        'created_by': createdBy?.toJSON(),
+        'updated': updated?.millisecondsSinceEpoch,
+        'created': created?.millisecondsSinceEpoch,
+      };
+}

lib/models/labelTask.dart

@@ -0,0 +1,18 @@
+import 'package:meta/meta.dart';
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/models/task.dart';
+
+class LabelTask {
+  final Label label;
+  final Task task;
+
+  LabelTask({@required this.label, @required this.task});
+
+  LabelTask.fromJson(Map<String, dynamic> json)
+      : label = new Label(id: json['label_id']),
+        task = null;
+
+  toJSON() => {
+        'label_id': label.id,
+      };
+}

lib/models/labelTaskBulk.dart

@@ -0,0 +1,15 @@
+import 'package:meta/meta.dart';
+import 'package:vikunja_app/models/label.dart';
+
+class LabelTaskBulk {
+  final List<Label> labels;
+
+  LabelTaskBulk({@required this.labels});
+
+  LabelTaskBulk.fromJson(Map<String, dynamic> json)
+      : labels = json['labels']?.map((label) => Label.fromJson(label));
+
+  toJSON() => {
+        'labels': labels.map((label) => label.toJSON()).toList(),
+      };
+}

lib/models/task.dart

@@ -1,48 +1,82 @@
-import 'package:vikunja_app/models/user.dart';
 import 'package:meta/meta.dart';
 
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/models/user.dart';
+import 'package:vikunja_app/utils/datetime_to_unix.dart';
+
 class Task {
-  final int id;
-  final DateTime created, updated, due;
-  final List<DateTime> reminders;
+  final int id, parentTaskId, priority;
+  final DateTime created, updated, dueDate, startDate, endDate;
+  final List<DateTime> reminderDates;
   final String text, description;
   final bool done;
-  final User owner;
+  final User createdBy;
+  final Duration repeatAfter;
+  final List<Task> subtasks;
+  final List<Label> labels;
 
   Task(
       {@required this.id,
+      this.text,
+      this.description,
+      this.done,
+      this.reminderDates,
+      this.dueDate,
+      this.startDate,
+      this.endDate,
+      this.parentTaskId,
+      this.priority,
+      this.repeatAfter,
+      this.subtasks,
+      this.labels,
       this.created,
       this.updated,
-      this.reminders,
-      this.due,
-      @required this.text,
-      this.description,
-      @required this.done,
-      @required this.owner});
+      this.createdBy});
 
   Task.fromJson(Map<String, dynamic> json)
       : id = json['id'],
-        updated = DateTime.fromMillisecondsSinceEpoch(json['updated']),
-        created = DateTime.fromMillisecondsSinceEpoch(json['created']),
-        reminders = (json['reminderDates'] as List<dynamic>)
-            ?.map((milli) => DateTime.fromMillisecondsSinceEpoch(milli))
-            ?.toList(),
-        due = DateTime.fromMillisecondsSinceEpoch(json['dueDate']),
-        description = json['description'],
         text = json['text'],
+        description = json['description'],
         done = json['done'],
-        owner = User.fromJson(json['createdBy']);
+        reminderDates = (json['reminderDates'] as List<dynamic>)
+            ?.map((ts) => dateTimeFromUnixTimestamp(ts))
+            ?.cast<DateTime>()
+            ?.toList(),
+        dueDate = dateTimeFromUnixTimestamp(json['dueDate']),
+        startDate = dateTimeFromUnixTimestamp(json['startDate']),
+        endDate = dateTimeFromUnixTimestamp(json['endDate']),
+        parentTaskId = json['parentTaskID'],
+        priority = json['priority'],
+        repeatAfter = Duration(seconds: json['repeatAfter']),
+        labels = (json['labels'] as List<dynamic>)
+            ?.map((label) => Label.fromJson(label))
+            ?.cast<Label>()
+            ?.toList(),
+        subtasks = (json['subtasks'] as List<dynamic>)
+            ?.map((subtask) => Task.fromJson(subtask))
+            ?.cast<Task>()
+            ?.toList(),
+        updated = dateTimeFromUnixTimestamp(json['updated']),
+        created = dateTimeFromUnixTimestamp(json['created']),
+        createdBy = User.fromJson(json['createdBy']);
 
   toJSON() => {
         'id': id,
-        'updated': updated?.millisecondsSinceEpoch,
-        'created': created?.millisecondsSinceEpoch,
-        'reminderDates':
-            reminders?.map((date) => date.millisecondsSinceEpoch)?.toList(),
-        'dueDate': due?.millisecondsSinceEpoch,
-        'description': description,
         'text': text,
+        'description': description,
         'done': done ?? false,
-        'createdBy': owner?.toJSON()
+        'reminderDates': reminderDates
+            ?.map((date) => datetimeToUnixTimestamp(date))
+            ?.toList(),
+        'dueDate': datetimeToUnixTimestamp(dueDate),
+        'startDate': datetimeToUnixTimestamp(startDate),
+        'endDate': datetimeToUnixTimestamp(endDate),
+        'priority': priority,
+        'repeatAfter': repeatAfter?.inSeconds,
+        'labels': labels?.map((label) => label.toJSON())?.toList(),
+        'subtasks': subtasks?.map((subtask) => subtask.toJSON())?.toList(),
+        'createdBy': createdBy?.toJSON(),
+        'updated': datetimeToUnixTimestamp(updated),
+        'created': datetimeToUnixTimestamp(created),
       };
 }

lib/pages/home.dart

@@ -89,8 +89,9 @@ class HomePageState extends State<HomePage> with AfterLayoutMixin<HomePage> {
       drawer: new Drawer(
           child: new Column(children: <Widget>[
         new UserAccountsDrawerHeader(
-          accountEmail:
-              currentUser?.email == null ? null : Text(currentUser.email),
+          // Removed until we find a way to disable the user email only for some occasions and not everywhere
+          //accountEmail:
+          //    currentUser?.email == null ? null : Text(currentUser.email),
           accountName:
               currentUser?.username == null ? null : Text(currentUser.username),
           onDetailsPressed: () {

lib/pages/list/list.dart

@@ -7,6 +7,7 @@ import 'package:vikunja_app/global.dart';
 import 'package:vikunja_app/models/list.dart';
 import 'package:vikunja_app/models/task.dart';
 import 'package:vikunja_app/pages/list/list_edit.dart';
+import 'package:vikunja_app/pages/list/task_edit.dart';
 
 class ListPage extends StatefulWidget {
   final TaskList taskList;
@@ -37,53 +38,87 @@ class _ListPageState extends State<ListPage> {
 
   @override
   Widget build(BuildContext context) {
-    return Scaffold(
-        appBar: AppBar(
-          title: new Text(_list.title),
-          actions: <Widget>[
-            IconButton(
-                icon: Icon(Icons.edit),
-                onPressed: () => Navigator.push(
-                    context,
-                    MaterialPageRoute(
-                        builder: (context) => ListEditPage(
-                              list: _list,
-                            ))))
-          ],
-        ),
-        body: !this._loading
-            ? RefreshIndicator(
-                child: _list.tasks.length > 0
-                    ? ListView(
-                        padding: EdgeInsets.symmetric(vertical: 8.0),
-                        children: ListTile.divideTiles(
-                                context: context, tiles: _listTasks())
-                            .toList(),
-                      )
-                    : Center(child: Text('This list is empty.')),
-                onRefresh: _loadList,
-              )
-            : Center(child: CircularProgressIndicator()),
-        floatingActionButton: Builder(
-          builder: (context) => FloatingActionButton(
-              onPressed: () => _addItemDialog(context), child: Icon(Icons.add)),
-        ));
-  }
-
-  List<Widget> _listTasks() {
     var tasks = (_list?.tasks?.map(_buildTile) ?? []).toList();
     tasks.addAll(_loadingTasks.map(_buildLoadingTile));
-    return tasks;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: new Text(_list.title),
+        actions: <Widget>[
+          IconButton(
+              icon: Icon(Icons.edit),
+              onPressed: () => Navigator.push(
+                  context,
+                  MaterialPageRoute(
+                      builder: (context) => ListEditPage(
+                            list: _list,
+                          ))))
+        ],
+      ),
+      body: !this._loading
+          ? RefreshIndicator(
+              onRefresh: _loadList,
+              child: _list.tasks.length > 0
+                  ? ListView(
+                      padding: EdgeInsets.symmetric(vertical: 8.0),
+                      children:
+                          ListTile.divideTiles(context: context, tiles: tasks)
+                              .toList(),
+                    )
+                  : Center(child: Text('This list is empty.')),
+            )
+          : Center(child: CircularProgressIndicator()),
+      floatingActionButton: Builder(
+        builder: (context) => FloatingActionButton(
+            onPressed: () => _addItemDialog(context), child: Icon(Icons.add)),
+      ),
+    );
   }
 
   TaskTile _buildTile(Task task) {
-    return TaskTile(task: task, loading: false);
+    return TaskTile(
+      task: task,
+      loading: false,
+      onEdit: () => Navigator.push(
+        context,
+        MaterialPageRoute(
+          builder: (context) => TaskEditPage(
+            task: task,
+          ),
+        ),
+      ),
+      onMarkedAsDone: (done) {
+        VikunjaGlobal.of(context)
+            .taskService
+            .update(Task(
+              id: task.id,
+              done: done,
+            ))
+            .then((newTask) => setState(() {
+                  // FIXME: This is ugly. We should use a redux to not have to do these kind of things.
+                  //  This is enough for now (it works™) but we should definitly fix it later.
+                  _list.tasks.asMap().forEach((i, t) {
+                    if (newTask.id == t.id) {
+                      _list.tasks[i] = newTask;
+                    }
+                  });
+                }));
+      },
+    );
   }
 
   TaskTile _buildLoadingTile(Task task) {
     return TaskTile(
       task: task,
       loading: true,
+      onEdit: () => Navigator.push(
+        context,
+        MaterialPageRoute(
+          builder: (context) => TaskEditPage(
+            task: task,
+          ),
+        ),
+      ),
     );
   }
 
@@ -110,8 +145,8 @@ class _ListPageState extends State<ListPage> {
 
   _addItem(String name, BuildContext context) {
     var globalState = VikunjaGlobal.of(context);
-    var newTask =
-        Task(id: null, text: name, owner: globalState.currentUser, done: false);
+    var newTask = Task(
+        id: null, text: name, createdBy: globalState.currentUser, done: false);
     setState(() => _loadingTasks.add(newTask));
     globalState.taskService.add(_list.id, newTask).then((task) {
       setState(() {
@@ -125,4 +160,12 @@ class _ListPageState extends State<ListPage> {
       ));
     });
   }
+
+  Future<Task> _updateTask(Task task, bool checked) {
+    // TODO use copyFrom
+    return VikunjaGlobal.of(context).taskService.update(Task(
+          id: task.id,
+          done: checked,
+        ));
+  }
 }

lib/pages/list/task_edit.dart

@@ -0,0 +1,436 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_typeahead/flutter_typeahead.dart';
+import 'package:vikunja_app/components/datetimePicker.dart';
+import 'package:vikunja_app/components/label.dart';
+import 'package:vikunja_app/global.dart';
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/models/task.dart';
+import 'package:vikunja_app/theme/button.dart';
+import 'package:vikunja_app/theme/buttonText.dart';
+import 'package:vikunja_app/utils/repeat_after_parse.dart';
+
+class TaskEditPage extends StatefulWidget {
+  final Task task;
+
+  TaskEditPage({this.task}) : super(key: Key(task.toString()));
+
+  @override
+  State<StatefulWidget> createState() => _TaskEditPageState();
+}
+
+class _TaskEditPageState extends State<TaskEditPage> {
+  final _formKey = GlobalKey<FormState>();
+  bool _loading = false;
+
+  int _priority;
+  DateTime _dueDate, _startDate, _endDate;
+  List<DateTime> _reminderDates;
+  String _text, _description, _repeatAfterType;
+  Duration _repeatAfter;
+  List<Label> _labels;
+  List<Label>
+      _suggestedLabels; // we use this to find the label object after a user taps on the suggestion, because the typeahead only uses strings, not full objects.
+  var _reminderInputs = new List<Widget>();
+  final _labelTypeAheadController = TextEditingController();
+
+  @override
+  Widget build(BuildContext ctx) {
+    // This builds the initial list of reminder inputs only once.
+    if (_reminderDates == null) {
+      _reminderDates = widget.task.reminderDates ?? new List();
+
+      _reminderDates?.asMap()?.forEach((i, time) =>
+          setState(() => _reminderInputs?.add(VikunjaDateTimePicker(
+                initialValue: time,
+                label: 'Reminder',
+                onSaved: (reminder) => _reminderDates[i] = reminder,
+              ))));
+    }
+
+    if (_labels == null) {
+      _labels = widget.task.labels ?? new List();
+    }
+
+    return Scaffold(
+      appBar: AppBar(
+        title: Text('Edit Task'),
+      ),
+      body: Builder(
+        builder: (BuildContext context) => SafeArea(
+          child: Form(
+            key: _formKey,
+            child: ListView(padding: const EdgeInsets.all(16.0), children: <
+                Widget>[
+              Padding(
+                padding: EdgeInsets.symmetric(vertical: 10.0),
+                child: TextFormField(
+                  maxLines: null,
+                  keyboardType: TextInputType.multiline,
+                  initialValue: widget.task.text,
+                  onSaved: (text) => _text = text,
+                  validator: (text) {
+                    if (text.length < 3 || text.length > 250) {
+                      return 'The text needs to have between 3 and 250 characters.';
+                    }
+                    return null;
+                  },
+                  decoration: new InputDecoration(
+                    labelText: 'Text',
+                    border: OutlineInputBorder(),
+                  ),
+                ),
+              ),
+              Padding(
+                padding: EdgeInsets.symmetric(vertical: 10.0),
+                child: TextFormField(
+                  maxLines: null,
+                  keyboardType: TextInputType.multiline,
+                  initialValue: widget.task.description,
+                  onSaved: (description) => _description = description,
+                  validator: (description) {
+                    if (description.length > 1000) {
+                      return 'The description can have a maximum of 1000 characters.';
+                    }
+                    return null;
+                  },
+                  decoration: new InputDecoration(
+                    labelText: 'Description',
+                    border: OutlineInputBorder(),
+                  ),
+                ),
+              ),
+              VikunjaDateTimePicker(
+                icon: Icon(Icons.access_time),
+                label: 'Due Date',
+                initialValue: widget.task.dueDate,
+                onSaved: (duedate) => _dueDate = duedate,
+              ),
+              VikunjaDateTimePicker(
+                label: 'Start Date',
+                initialValue: widget.task.startDate,
+                onSaved: (startDate) => _startDate = startDate,
+              ),
+              VikunjaDateTimePicker(
+                label: 'End Date',
+                initialValue: widget.task.endDate,
+                onSaved: (endDate) => _endDate = endDate,
+              ),
+              Row(
+                children: [
+                  Expanded(
+                    flex: 2,
+                    child: TextFormField(
+                      keyboardType: TextInputType.number,
+                      initialValue: getRepeatAfterValueFromDuration(
+                              widget.task.repeatAfter)
+                          ?.toString(),
+                      onSaved: (repeatAfter) => _repeatAfter =
+                          getDurationFromType(repeatAfter, _repeatAfterType),
+                      decoration: new InputDecoration(
+                        labelText: 'Repeat after',
+                        border: InputBorder.none,
+                        icon: Icon(Icons.repeat),
+                      ),
+                    ),
+                  ),
+                  Expanded(
+                    child: DropdownButton<String>(
+                      isExpanded: true,
+                      isDense: true,
+                      value: _repeatAfterType ??
+                          getRepeatAfterTypeFromDuration(
+                              widget.task.repeatAfter),
+                      onChanged: (String newValue) {
+                        setState(() {
+                          _repeatAfterType = newValue;
+                        });
+                      },
+                      items: <String>[
+                        'Hours',
+                        'Days',
+                        'Weeks',
+                        'Months',
+                        'Years'
+                      ].map<DropdownMenuItem<String>>((String value) {
+                        return DropdownMenuItem<String>(
+                          value: value,
+                          child: Text(value),
+                        );
+                      }).toList(),
+                    ),
+                  ),
+                ],
+              ),
+              Column(
+                children: _reminderInputs,
+              ),
+              GestureDetector(
+                  child: Padding(
+                    padding: EdgeInsets.symmetric(vertical: 10),
+                    child: Row(
+                      children: <Widget>[
+                        Padding(
+                            padding: EdgeInsets.only(right: 15, left: 2),
+                            child: Icon(
+                              Icons.alarm_add,
+                              color: Colors.grey,
+                            )),
+                        Text(
+                          'Add a reminder',
+                          style: TextStyle(
+                            color: Colors.grey,
+                            fontSize: 16,
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+                  onTap: () {
+                    // We add a new entry every time we add a new input, to make sure all inputs have a place where they can put their value.
+                    _reminderDates.add(null);
+                    var currentIndex = _reminderDates.length - 1;
+
+                    // FIXME: Why does putting this into a row fails?
+                    setState(() => _reminderInputs.add(Row(
+                          children: <Widget>[
+                            VikunjaDateTimePicker(
+                              label: 'Reminder',
+                              onSaved: (reminder) =>
+                                  _reminderDates[currentIndex] = reminder,
+                            ),
+                            GestureDetector(
+                              onTap: () => print('tapped'),
+                              child: Icon(Icons.close),
+                            )
+                          ],
+                        )));
+                  }),
+              InputDecorator(
+                isEmpty: _priority == null,
+                decoration: InputDecoration(
+                  icon: const Icon(Icons.flag),
+                  labelText: 'Priority',
+                  border: InputBorder.none,
+                ),
+                child: new DropdownButton<String>(
+                  value: _priorityToString(_priority),
+                  isExpanded: true,
+                  isDense: true,
+                  onChanged: (String newValue) {
+                    setState(() {
+                      _priority = _priorityFromString(newValue);
+                    });
+                  },
+                  items: ['Unset', 'Low', 'Medium', 'High', 'Urgent', 'DO NOW']
+                      .map((String value) {
+                    return new DropdownMenuItem(
+                      value: value,
+                      child: new Text(value),
+                    );
+                  }).toList(),
+                ),
+              ),
+              Wrap(
+                  spacing: 10,
+                  children: _labels.map((Label label) {
+                    return LabelComponent(
+                      label: label,
+                      onDelete: () {
+                        _removeLabel(label);
+                      },
+                    );
+                  }).toList()),
+              Row(
+                children: <Widget>[
+                  Container(
+                    width: MediaQuery.of(context).size.width - 80,
+                    child: TypeAheadFormField(
+                      textFieldConfiguration: TextFieldConfiguration(
+                          controller: _labelTypeAheadController,
+                          decoration:
+                              InputDecoration(labelText: 'Add a new label')),
+                      suggestionsCallback: (pattern) {
+                        return _searchLabel(pattern);
+                      },
+                      itemBuilder: (context, suggestion) {
+                        return ListTile(
+                          title: Text(suggestion),
+                        );
+                      },
+                      transitionBuilder: (context, suggestionsBox, controller) {
+                        return suggestionsBox;
+                      },
+                      onSuggestionSelected: (suggestion) {
+                        _addLabel(suggestion);
+                      },
+                    ),
+                  ),
+                  IconButton(
+                    onPressed: () =>
+                        _createAndAddLabel(_labelTypeAheadController.text),
+                    icon: Icon(Icons.add),
+                  )
+                ],
+              ),
+              Builder(
+                  builder: (context) => Padding(
+                      padding: EdgeInsets.symmetric(vertical: 10.0),
+                      child: FancyButton(
+                        onPressed: !_loading
+                            ? () {
+                                if (_formKey.currentState.validate()) {
+                                  Form.of(context).save();
+                                  _saveTask(context);
+                                }
+                              }
+                            : null,
+                        child: _loading
+                            ? CircularProgressIndicator()
+                            : VikunjaButtonText('Save'),
+                      ))),
+            ]),
+          ),
+        ),
+      ),
+    );
+  }
+
+  _saveTask(BuildContext context) async {
+    setState(() => _loading = true);
+
+    // Removes all reminders with no value set.
+    _reminderDates.removeWhere((d) => d == null);
+
+    Task updatedTask = Task(
+      id: widget.task.id,
+      text: _text,
+      description: _description,
+      done: widget.task.done,
+      reminderDates: _reminderDates,
+      dueDate: _dueDate,
+      startDate: _startDate,
+      endDate: _endDate,
+      priority: _priority,
+      repeatAfter: _repeatAfter,
+    );
+
+    // update the labels
+    VikunjaGlobal.of(context)
+        .labelTaskBulkService
+        .update(updatedTask, _labels)
+        .catchError((err) {
+      setState(() => _loading = false);
+      Scaffold.of(context).showSnackBar(
+        SnackBar(
+          content: Text('Something went wrong: ' + err.toString()),
+        ),
+      );
+    });
+
+    VikunjaGlobal.of(context).taskService.update(updatedTask).then((_) {
+      setState(() => _loading = false);
+      Scaffold.of(context).showSnackBar(SnackBar(
+        content: Text('The task was updated successfully!'),
+      ));
+    }).catchError((err) {
+      setState(() => _loading = false);
+      Scaffold.of(context).showSnackBar(
+        SnackBar(
+          content: Text('Something went wrong: ' + err.toString()),
+          action: SnackBarAction(
+              label: 'CLOSE',
+              onPressed: Scaffold.of(context).hideCurrentSnackBar),
+        ),
+      );
+    });
+  }
+
+  _removeLabel(Label label) {
+    setState(() {
+      _labels.removeWhere((l) => l.id == label.id);
+    });
+  }
+
+  _searchLabel(String query) {
+    return VikunjaGlobal.of(context)
+        .labelService
+        .getAll(query: query)
+        .then((labels) {
+      // Only show those labels which aren't already added to the task
+      labels.removeWhere((labelToRemove) => _labels.contains(labelToRemove));
+      _suggestedLabels = labels;
+      return labels.map((label) => label.title).toList();
+    });
+  }
+
+  _addLabel(String labelTitle) {
+    // FIXME: This is not an optimal solution...
+    bool found = false;
+    _suggestedLabels.forEach((label) {
+      if (label.title == labelTitle) {
+        _labels.add(label);
+        found = true;
+      }
+    });
+
+    if (found) {
+      _labelTypeAheadController.clear();
+    }
+  }
+
+  _createAndAddLabel(String labelTitle) {
+    // Only add a label if there are none to add
+    if (labelTitle == '' || _suggestedLabels.length > 0) {
+      return;
+    }
+
+    Label newLabel = Label(title: labelTitle);
+    VikunjaGlobal.of(context)
+        .labelService
+        .create(newLabel)
+        .then((createdLabel) {
+      setState(() {
+        _labels.add(createdLabel);
+        _labelTypeAheadController.clear();
+      });
+    });
+  }
+
+  // FIXME: Move the following two functions to an extra class or type.
+  _priorityFromString(String priority) {
+    switch (priority) {
+      case 'Low':
+        return 1;
+      case 'Medium':
+        return 2;
+      case 'High':
+        return 3;
+      case 'Urgent':
+        return 4;
+      case 'DO NOW':
+        return 5;
+      default:
+        // unset
+        return 0;
+    }
+  }
+
+  _priorityToString(int priority) {
+    switch (priority) {
+      case 0:
+        return 'Unset';
+      case 1:
+        return 'Low';
+      case 2:
+        return 'Medium';
+      case 3:
+        return 'High';
+      case 4:
+        return 'Urgent';
+      case 5:
+        return 'DO NOW';
+      default:
+        return null;
+    }
+  }
+}

lib/pages/namespace/namespace.dart

@@ -75,12 +75,6 @@ class _NamespacePageState extends State<NamespacePage>
     );
   }
 
-  @override
-  void didChangeDependencies() {
-    super.didChangeDependencies();
-    _loadLists();
-  }
-
   Future _removeList(TaskList list) {
     return VikunjaGlobal.of(context)
         .listService

lib/pages/placeholder.dart

@@ -4,20 +4,24 @@ class PlaceholderPage extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return new Container(
-        padding: EdgeInsets.only(left: 16.0),
-        child: new Column(
+        padding: EdgeInsets.all(16),
+        child: Center(
+            child: Column(
           mainAxisAlignment: MainAxisAlignment.start,
           children: <Widget>[
-            new Container(
+            Container(
               padding: EdgeInsets.only(top: 32.0),
-              child: new Text(
+              child: Text(
                 'Welcome to Vikunja',
                 style: Theme.of(context).textTheme.headline,
               ),
             ),
-            new Text('Please select a namespace by tapping the  ☰  icon.',
-                style: Theme.of(context).textTheme.subhead),
+            Padding(
+              padding: EdgeInsets.symmetric(vertical: 10),
+              child: Text('Please select a namespace by tapping the  ☰  icon.',
+                  style: Theme.of(context).textTheme.subhead),
+            )
           ],
-        ));
+        )));
   }
 }

lib/service/mocked_services.dart

@@ -39,7 +39,7 @@ var _tasks = {
   1: Task(
     id: 1,
     text: 'Task 1',
-    owner: _users[1],
+    createdBy: _users[1],
     updated: DateTime.now(),
     created: DateTime.now(),
     description: 'A descriptive task',

lib/service/services.dart

@@ -1,5 +1,7 @@
 import 'dart:async';
 
+import 'package:vikunja_app/models/label.dart';
+import 'package:vikunja_app/models/labelTask.dart';
 import 'package:vikunja_app/models/list.dart';
 import 'package:vikunja_app/models/namespace.dart';
 import 'package:vikunja_app/models/task.dart';
@@ -33,3 +35,21 @@ abstract class UserService {
   Future<UserTokenPair> register(String username, email, password);
   Future<User> getCurrentUser();
 }
+
+abstract class LabelService {
+  Future<List<Label>> getAll({String query});
+  Future<Label> get(int labelID);
+  Future<Label> create(Label label);
+  Future<Label> delete(Label label);
+  Future<Label> update(Label label);
+}
+
+abstract class LabelTaskService {
+  Future<List<Label>> getAll(LabelTask lt, {String query});
+  Future<Label> create(LabelTask lt);
+  Future<Label> delete(LabelTask lt);
+}
+
+abstract class LabelTaskBulkService {
+  Future<List<Label>> update(Task task, List<Label> labels);
+}

lib/theme/constants.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:intl/intl.dart';
 
 /////////
 // Colors
@@ -17,9 +18,15 @@ const vButtonColor = vPrimary;
 const vButtonTextColor = vWhite;
 const vButtonShadow = Color(0xFFb2d9ff);
 
+const vLabelLight = Color(0xFFf2f2f2);
+const vLabelDark = Color(0xFF4a4a4a);
+const vLabelDefaultColor = vGreen;
+
 ///////////
 // Paddings
 ////////
 const vStandardVerticalPadding = EdgeInsets.symmetric(vertical: 5.0);
 const vStandardHorizontalPadding = EdgeInsets.symmetric(horizontal: 5.0);
 const vStandardPadding = EdgeInsets.symmetric(horizontal: 5.0, vertical: 5.0);
+
+var vDateFormatLong = DateFormat("EEEE, MMMM d, yyyy 'at' H:mm");

lib/utils/datetime_to_unix.dart

@@ -0,0 +1,11 @@
+datetimeToUnixTimestamp(DateTime dt) {
+  return dt?.millisecondsSinceEpoch == null
+      ? null
+      : (dt.millisecondsSinceEpoch / 1000).round();
+}
+
+dateTimeFromUnixTimestamp(int timestamp) {
+  return timestamp == null
+      ? 0
+      : DateTime.fromMillisecondsSinceEpoch(timestamp * 1000);
+}

lib/utils/repeat_after_parse.dart

@@ -0,0 +1,66 @@
+getRepeatAfterTypeFromDuration(Duration repeatAfter) {
+  if (repeatAfter == null || repeatAfter.inSeconds == 0) {
+    return null;
+  }
+
+  // if its dividable by 24, its something with days, otherwise hours
+  if (repeatAfter.inHours % 24 == 0) {
+    if (repeatAfter.inDays % 7 == 0) {
+      return 'Weeks';
+    } else if (repeatAfter.inDays % 365 == 0) {
+      return 'Years';
+    } else if (repeatAfter.inDays % 30 == 0) {
+      return 'Months';
+    } else {
+      return 'Days';
+    }
+  }
+  return 'Hours';
+}
+
+getRepeatAfterValueFromDuration(Duration repeatAfter) {
+  if (repeatAfter == null || repeatAfter.inSeconds == 0) {
+    return null;
+  }
+
+  // if its dividable by 24, its something with days, otherwise hours
+  if (repeatAfter.inHours % 24 == 0) {
+    if (repeatAfter.inDays % 7 == 0) {
+      // Weeks
+      return (repeatAfter.inDays / 7).round();
+    } else if (repeatAfter.inDays % 365 == 0) {
+      // Years
+      return (repeatAfter.inDays / 365).round();
+    } else if (repeatAfter.inDays % 30 == 0) {
+      // Months
+      return (repeatAfter.inDays / 30).round();
+    } else {
+      return repeatAfter.inDays; // Days
+    }
+  }
+
+  // Otherwise Hours
+  return repeatAfter.inHours;
+}
+
+getDurationFromType(String value, String type) {
+  // Return an empty duration if either of the values is not set
+  if (value == null || value == '' || type == null || type == '') {
+    return Duration();
+  }
+
+  int val = int.parse(value);
+
+  switch (type) {
+    case 'Hours':
+      return Duration(hours: val);
+    case 'Days':
+      return Duration(days: val);
+    case 'Weeks':
+      return Duration(days: val * 7);
+    case 'Months':
+      return Duration(days: val * 30);
+    case 'Years':
+      return Duration(days: val * 365);
+  }
+}

pubspec.yaml

@@ -13,10 +13,13 @@ dependencies:
   flutter_secure_storage: 3.3.1+1
   http: 0.12.0+3
   after_layout: ^1.0.7
+  datetime_picker_formfield: ^0.1.8
+  flutter_typeahead: ^1.2.1
 
 dev_dependencies:
   flutter_test:
     sdk: flutter
+  test: ^1.4.0
   flutter_launcher_icons: "^0.6.1"
 
 flutter_icons:

test/parse_label_color.dart

@@ -0,0 +1,22 @@
+import 'dart:convert';
+import 'dart:ui';
+
+import 'package:test/test.dart';
+import 'package:vikunja_app/models/label.dart';
+
+void main() {
+  test('label color from json', () {
+    final String json = '{"TaskID": 123,"id": 1,"title": "this","description": "","hex_color": "e8e8e8","created_by":{"id": 1,"username": "user","email": "test@example.com","created": 1537855131,"updated": 1545233325},"created": 1552903790,"updated": 1552903790}';
+    final JsonDecoder _decoder = new JsonDecoder();
+    Label label = Label.fromJson(_decoder.convert(json));
+
+    expect(label.color, Color(0xFFe8e8e8));
+  });
+
+  test('hex color string from object', () {
+    Label label = Label(id: 1, color: Color(0xFFe8e8e8));
+    var json = label.toJSON();
+
+    expect(json.toString(), '{id: 1, title: null, description: null, hex_color: e8e8e8, created_by: null, updated: null, created: null}');
+  });
+}

test/parse_repeat_after_test.dart

@@ -0,0 +1,76 @@
+import 'package:test/test.dart';
+import 'package:vikunja_app/utils/repeat_after_parse.dart';
+
+void main() {
+  test('Repeat after hours', () {
+    Duration testDuration = Duration(hours: 6);
+
+    expect(getRepeatAfterTypeFromDuration(testDuration), 'Hours');
+    expect(getRepeatAfterValueFromDuration(testDuration), 6);
+  });
+
+  test('Repeat after days', () {
+    Duration testDuration = Duration(days: 6);
+
+    expect(getRepeatAfterTypeFromDuration(testDuration), 'Days');
+    expect(getRepeatAfterValueFromDuration(testDuration), 6);
+  });
+
+  test('Repeat after weeks', () {
+    Duration testDuration = Duration(days: 6 * 7);
+
+    expect(getRepeatAfterTypeFromDuration(testDuration), 'Weeks');
+    expect(getRepeatAfterValueFromDuration(testDuration), 6);
+  });
+
+  test('Repeat after months', () {
+    Duration testDuration = Duration(days: 6 * 30);
+
+    expect(getRepeatAfterTypeFromDuration(testDuration), 'Months');
+    expect(getRepeatAfterValueFromDuration(testDuration), 6);
+  });
+
+  test('Repeat after years', () {
+    Duration testDuration = Duration(days: 6 * 365);
+
+    expect(getRepeatAfterTypeFromDuration(testDuration), 'Years');
+    expect(getRepeatAfterValueFromDuration(testDuration), 6);
+  });
+
+  test('Repeat null value', () {
+    Duration testDuration = Duration();
+
+    expect(getRepeatAfterTypeFromDuration(testDuration), null);
+    expect(getRepeatAfterValueFromDuration(testDuration), null);
+  });
+
+  test('Hours to duration', () {
+    Duration parsedDuration = getDurationFromType('6', 'Hours');
+    expect(parsedDuration, Duration(hours: 6));
+  });
+
+  test('Days to duration', () {
+    Duration parsedDuration = getDurationFromType('6', 'Days');
+    expect(parsedDuration, Duration(days: 6));
+  });
+
+  test('Weeks to duration', () {
+    Duration parsedDuration = getDurationFromType('6', 'Weeks');
+    expect(parsedDuration, Duration(days: 6 * 7));
+  });
+
+  test('Months to duration', () {
+    Duration parsedDuration = getDurationFromType('6', 'Months');
+    expect(parsedDuration, Duration(days: 6 * 30));
+  });
+
+  test('Years to duration', () {
+    Duration parsedDuration = getDurationFromType('6', 'Years');
+    expect(parsedDuration, Duration(days: 6 * 365));
+  });
+
+  test('null to duration', () {
+    Duration parsedDuration = getDurationFromType(null, null);
+    expect(parsedDuration, Duration());
+  });
+}

test/task_json_decode_test.dart

@@ -0,0 +1,52 @@
+import 'dart:convert';
+
+import 'package:vikunja_app/models/task.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('Check encoding with all values set', () {
+    final String json = '{"id": 1,"text": "test","description": "Lorem Ipsum","done": true,"dueDate": 1543834800,"reminderDates": [1543834800,1544612400],"repeatAfter": 3600,"parentTaskID": 0,"priority": 100,"startDate": 1543834800,"endDate": 1543835000,"assignees": null,"labels": null,"subtasks": null,"created": 1542465818,"updated": 1552771527,"createdBy": {"id": 1,"username": "user","email": "test@example.com","created": 1537855131,"updated": 1545233325}}';
+    final JsonDecoder _decoder = new JsonDecoder();
+    final task = Task.fromJson(_decoder.convert(json));
+
+    expect(task.id, 1);
+    expect(task.text, 'test');
+    expect(task.description, 'Lorem Ipsum');
+    expect(task.done, true);
+    expect(task.reminderDates, [
+      DateTime.fromMillisecondsSinceEpoch(1543834800 * 1000),
+      DateTime.fromMillisecondsSinceEpoch(1544612400 * 1000),
+    ]);
+    expect(task.dueDate, DateTime.fromMillisecondsSinceEpoch(1543834800 * 1000));
+    expect(task.repeatAfter, Duration(seconds: 3600));
+    expect(task.parentTaskId, 0);
+    expect(task.priority, 100);
+    expect(task.startDate, DateTime.fromMillisecondsSinceEpoch(1543834800 * 1000));
+    expect(task.endDate, DateTime.fromMillisecondsSinceEpoch(1543835000 * 1000));
+    expect(task.labels, null);
+    expect(task.subtasks, null);
+    expect(task.created, DateTime.fromMillisecondsSinceEpoch(1542465818 * 1000));
+    expect(task.updated, DateTime.fromMillisecondsSinceEpoch(1552771527 * 1000));
+  });
+  test('Check encoding with reminder dates as null', () {
+    final String json = '{"id": 1,"text": "test","description": "Lorem Ipsum","done": true,"dueDate": 1543834800,"reminderDates": null,"repeatAfter": 3600,"parentTaskID": 0,"priority": 100,"startDate": 1543834800,"endDate": 1543835000,"assignees": null,"labels": null,"subtasks": null,"created": 1542465818,"updated": 1552771527,"createdBy": {"id": 1,"username": "user","email": "test@example.com","created": 1537855131,"updated": 1545233325}}';
+    final JsonDecoder _decoder = new JsonDecoder();
+    final task = Task.fromJson(_decoder.convert(json));
+
+    expect(task.id, 1);
+    expect(task.text, 'test');
+    expect(task.description, 'Lorem Ipsum');
+    expect(task.done, true);
+    expect(task.reminderDates, null);
+    expect(task.dueDate, DateTime.fromMillisecondsSinceEpoch(1543834800 * 1000));
+    expect(task.repeatAfter, Duration(seconds: 3600));
+    expect(task.parentTaskId, 0);
+    expect(task.priority, 100);
+    expect(task.startDate, DateTime.fromMillisecondsSinceEpoch(1543834800 * 1000));
+    expect(task.endDate, DateTime.fromMillisecondsSinceEpoch(1543835000 * 1000));
+    expect(task.labels, null);
+    expect(task.subtasks, null);
+    expect(task.created, DateTime.fromMillisecondsSinceEpoch(1542465818 * 1000));
+    expect(task.updated, DateTime.fromMillisecondsSinceEpoch(1552771527 * 1000));
+  });
+}