Fehlerkorrekturen

lib/content_views/task_list_page.dart

@@ -9,6 +9,7 @@ import 'package:stadtbote/content_views/utils/header_info.dart';
 import 'package:stadtbote/messages/pop_content_view_message.dart';
 import 'package:stadtbote/model/job.dart';
 import 'package:stadtbote/model/job_tour.dart';
+import 'package:stadtbote/model/pictures.dart';
 import 'package:stadtbote/popups/tasks_popups/arrived_popup.dart';
 import 'package:stadtbote/popups/tasks_popups/commision_number_popup.dart';
 import 'package:stadtbote/popups/tasks_popups/pickup_delivery_status_popup.dart';
@@ -65,8 +66,6 @@ class _TaskListPageState extends State<TaskListPage> {
 
   late List<TaskInfo> _taskList;
 
-  List<Uint8List> _photos = [];
-
   late String _commisionNumber;
 
   @override
@@ -319,9 +318,21 @@ class _TaskListPageState extends State<TaskListPage> {
   }
 
   _processTakePhotos(TaskInfo taskInfo) {
-    showTakePhotosPopup(context, taskInfo, (List<Uint8List>? photos) {
+    showTakePhotosPopup(context, taskInfo, (List<Uint8List>? photos) async {
       if (photos != null) {
-        _photos = photos;
+        await MyApp.isarInstance.writeTxn(() async {
+          await MyApp.isarInstance.pictures.filter().tourIdEqualTo(widget.tour.id).deleteAll();
+
+          for (int i = 0; i < photos.length; i++) {
+            var pictureData = photos[i];
+
+            var picture = Picture();
+            picture.number = i;
+            picture.tourId = widget.tour.id;
+            picture.data = base64Encode(pictureData);
+            await MyApp.isarInstance.pictures.put(picture);
+          }
+        });
 
         taskInfo.additionalText = "Fotos aufgenommen";
         taskInfo.completed = true;
@@ -512,16 +523,16 @@ class _TaskListPageState extends State<TaskListPage> {
   }
 
   _sendImages() {
-    Future.delayed(const Duration(seconds: 1), () {
+    Future.delayed(const Duration(seconds: 1), () async {
-      if (_photos.isNotEmpty) {
+      var pictures = await MyApp.isarInstance.pictures.where().filter().tourIdEqualTo(widget.tour.id).findAll();
-        int photoIndex = 0;
 
-        for (var photoData in _photos) {
+      if (pictures.isNotEmpty) {
+        for (var picture in pictures) {
           var message = PicData();
-          message.trId = widget.tour.id;
+          message.trId = picture.tourId;
-          message.num = photoIndex;
+          message.num = picture.number;
           message.time = DateTime.now().millisecondsSinceEpoch;
-          message.data = base64Encode(photoData);
+          message.data = picture.data;
 
           MessageService().publish<PublishPayloadMessage>(Constants.messageTopicPublishPayload, arguments: PublishPayloadMessage(topic: "pic", message: message.toJson()));
         }

lib/main.dart

@@ -8,6 +8,7 @@ import 'package:stadtbote/messages/pop_content_view_message.dart';
 import 'package:stadtbote/model/enqueued_message.dart';
 import 'package:stadtbote/model/log_entry.dart';
 import 'package:stadtbote/model/message.dart';
+import 'package:stadtbote/model/pictures.dart';
 import 'package:stadtbote/model/rank.dart';
 import 'package:stadtbote/model/location_status.dart';
 import 'package:stadtbote/model/task_info.dart';
@@ -39,7 +40,8 @@ Future<void> main() async {
     MessageSchema,
     EnqueuedMessageSchema,
     LogEntrySchema,
-    RankingSchema
+    RankingSchema,
+    PictureSchema
   ], directory: dir.path);
 
   runZonedGuarded(() {}, (error, stackTrace) {

lib/model/pictures.dart

@@ -0,0 +1,20 @@
+import 'package:flutter/foundation.dart';
+import 'package:isar/isar.dart';
+
+part 'pictures.g.dart';
+
+@collection
+class Picture {
+  late Id id;
+
+  late int tourId;
+
+  late int number;
+
+  late String data;
+
+  Picture() {
+    id = Isar.autoIncrement;
+  }
+}
+

lib/model/pictures.g.dart

@@ -0,0 +1,623 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'pictures.dart';
+
+// **************************************************************************
+// IsarCollectionGenerator
+// **************************************************************************
+
+// coverage:ignore-file
+// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types
+
+extension GetPictureCollection on Isar {
+  IsarCollection<Picture> get pictures => this.collection();
+}
+
+const PictureSchema = CollectionSchema(
+  name: r'Picture',
+  id: 985668904418580614,
+  properties: {
+    r'data': PropertySchema(
+      id: 0,
+      name: r'data',
+      type: IsarType.string,
+    ),
+    r'number': PropertySchema(
+      id: 1,
+      name: r'number',
+      type: IsarType.long,
+    ),
+    r'tourId': PropertySchema(
+      id: 2,
+      name: r'tourId',
+      type: IsarType.long,
+    )
+  },
+  estimateSize: _pictureEstimateSize,
+  serialize: _pictureSerialize,
+  deserialize: _pictureDeserialize,
+  deserializeProp: _pictureDeserializeProp,
+  idName: r'id',
+  indexes: {},
+  links: {},
+  embeddedSchemas: {},
+  getId: _pictureGetId,
+  getLinks: _pictureGetLinks,
+  attach: _pictureAttach,
+  version: '3.1.0+1',
+);
+
+int _pictureEstimateSize(
+  Picture object,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  var bytesCount = offsets.last;
+  bytesCount += 3 + object.data.length * 3;
+  return bytesCount;
+}
+
+void _pictureSerialize(
+  Picture object,
+  IsarWriter writer,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  writer.writeString(offsets[0], object.data);
+  writer.writeLong(offsets[1], object.number);
+  writer.writeLong(offsets[2], object.tourId);
+}
+
+Picture _pictureDeserialize(
+  Id id,
+  IsarReader reader,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  final object = Picture();
+  object.data = reader.readString(offsets[0]);
+  object.id = id;
+  object.number = reader.readLong(offsets[1]);
+  object.tourId = reader.readLong(offsets[2]);
+  return object;
+}
+
+P _pictureDeserializeProp<P>(
+  IsarReader reader,
+  int propertyId,
+  int offset,
+  Map<Type, List<int>> allOffsets,
+) {
+  switch (propertyId) {
+    case 0:
+      return (reader.readString(offset)) as P;
+    case 1:
+      return (reader.readLong(offset)) as P;
+    case 2:
+      return (reader.readLong(offset)) as P;
+    default:
+      throw IsarError('Unknown property with id $propertyId');
+  }
+}
+
+Id _pictureGetId(Picture object) {
+  return object.id;
+}
+
+List<IsarLinkBase<dynamic>> _pictureGetLinks(Picture object) {
+  return [];
+}
+
+void _pictureAttach(IsarCollection<dynamic> col, Id id, Picture object) {
+  object.id = id;
+}
+
+extension PictureQueryWhereSort on QueryBuilder<Picture, Picture, QWhere> {
+  QueryBuilder<Picture, Picture, QAfterWhere> anyId() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(const IdWhereClause.any());
+    });
+  }
+}
+
+extension PictureQueryWhere on QueryBuilder<Picture, Picture, QWhereClause> {
+  QueryBuilder<Picture, Picture, QAfterWhereClause> idEqualTo(Id id) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(IdWhereClause.between(
+        lower: id,
+        upper: id,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterWhereClause> idNotEqualTo(Id id) {
+    return QueryBuilder.apply(this, (query) {
+      if (query.whereSort == Sort.asc) {
+        return query
+            .addWhereClause(
+              IdWhereClause.lessThan(upper: id, includeUpper: false),
+            )
+            .addWhereClause(
+              IdWhereClause.greaterThan(lower: id, includeLower: false),
+            );
+      } else {
+        return query
+            .addWhereClause(
+              IdWhereClause.greaterThan(lower: id, includeLower: false),
+            )
+            .addWhereClause(
+              IdWhereClause.lessThan(upper: id, includeUpper: false),
+            );
+      }
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterWhereClause> idGreaterThan(Id id,
+      {bool include = false}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IdWhereClause.greaterThan(lower: id, includeLower: include),
+      );
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterWhereClause> idLessThan(Id id,
+      {bool include = false}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IdWhereClause.lessThan(upper: id, includeUpper: include),
+      );
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterWhereClause> idBetween(
+    Id lowerId,
+    Id upperId, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(IdWhereClause.between(
+        lower: lowerId,
+        includeLower: includeLower,
+        upper: upperId,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+}
+
+extension PictureQueryFilter
+    on QueryBuilder<Picture, Picture, QFilterCondition> {
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataEqualTo(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'data',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataGreaterThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'data',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataLessThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'data',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataBetween(
+    String lower,
+    String upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'data',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataStartsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.startsWith(
+        property: r'data',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataEndsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.endsWith(
+        property: r'data',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataContains(
+      String value,
+      {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.contains(
+        property: r'data',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataMatches(
+      String pattern,
+      {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.matches(
+        property: r'data',
+        wildcard: pattern,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'data',
+        value: '',
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> dataIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        property: r'data',
+        value: '',
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> idEqualTo(Id value) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'id',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> idGreaterThan(
+    Id value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'id',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> idLessThan(
+    Id value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'id',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> idBetween(
+    Id lower,
+    Id upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'id',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> numberEqualTo(
+      int value) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'number',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> numberGreaterThan(
+    int value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'number',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> numberLessThan(
+    int value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'number',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> numberBetween(
+    int lower,
+    int upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'number',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> tourIdEqualTo(
+      int value) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'tourId',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> tourIdGreaterThan(
+    int value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'tourId',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> tourIdLessThan(
+    int value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'tourId',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterFilterCondition> tourIdBetween(
+    int lower,
+    int upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'tourId',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+}
+
+extension PictureQueryObject
+    on QueryBuilder<Picture, Picture, QFilterCondition> {}
+
+extension PictureQueryLinks
+    on QueryBuilder<Picture, Picture, QFilterCondition> {}
+
+extension PictureQuerySortBy on QueryBuilder<Picture, Picture, QSortBy> {
+  QueryBuilder<Picture, Picture, QAfterSortBy> sortByData() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'data', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> sortByDataDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'data', Sort.desc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> sortByNumber() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'number', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> sortByNumberDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'number', Sort.desc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> sortByTourId() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'tourId', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> sortByTourIdDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'tourId', Sort.desc);
+    });
+  }
+}
+
+extension PictureQuerySortThenBy
+    on QueryBuilder<Picture, Picture, QSortThenBy> {
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByData() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'data', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByDataDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'data', Sort.desc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenById() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'id', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByIdDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'id', Sort.desc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByNumber() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'number', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByNumberDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'number', Sort.desc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByTourId() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'tourId', Sort.asc);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QAfterSortBy> thenByTourIdDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'tourId', Sort.desc);
+    });
+  }
+}
+
+extension PictureQueryWhereDistinct
+    on QueryBuilder<Picture, Picture, QDistinct> {
+  QueryBuilder<Picture, Picture, QDistinct> distinctByData(
+      {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'data', caseSensitive: caseSensitive);
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QDistinct> distinctByNumber() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'number');
+    });
+  }
+
+  QueryBuilder<Picture, Picture, QDistinct> distinctByTourId() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'tourId');
+    });
+  }
+}
+
+extension PictureQueryProperty
+    on QueryBuilder<Picture, Picture, QQueryProperty> {
+  QueryBuilder<Picture, int, QQueryOperations> idProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'id');
+    });
+  }
+
+  QueryBuilder<Picture, String, QQueryOperations> dataProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'data');
+    });
+  }
+
+  QueryBuilder<Picture, int, QQueryOperations> numberProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'number');
+    });
+  }
+
+  QueryBuilder<Picture, int, QQueryOperations> tourIdProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'tourId');
+    });
+  }
+}