diameter/lib/models/log_event.dart

import 'package:diameter/main.dart';
import 'package:diameter/models/basal_profile.dart';
import 'package:diameter/models/bolus_profile.dart';
import 'package:diameter/models/log_event_type.dart';
import 'package:objectbox/objectbox.dart';
import 'package:diameter/objectbox.g.dart' show LogEvent_, LogEventType_;

@Entity(uid: 4303325892753185970)
@Sync()
class LogEvent {
  static final Box<LogEvent> box = objectBox.store.box<LogEvent>();

  // properties
  int id;
  bool deleted;
  @Property(type: PropertyType.date)
  DateTime time;
  @Property(type: PropertyType.date)
  DateTime? endTime;
  bool hasEndTime;
  int? reminderDuration;
  String? notes;
  String? source;

  @Transient()
  String? title;
  @Transient()
  bool isEndEvent = false;

  // relations
  final eventType = ToOne<LogEventType>();
  final bolusProfile = ToOne<BolusProfile>();
  final basalProfile = ToOne<BasalProfile>();

  // constructor
  LogEvent({
    this.id = 0,
    this.deleted = false,
    required this.time,
    this.endTime,
    this.hasEndTime = false,
    this.reminderDuration,
    this.notes,
    this.source,
  });

  // methods
  static LogEvent? get(int id) => box.get(id);
  static void put(LogEvent logEvent) => box.put(logEvent);

  static void remove(int id) {
    final item = box.get(id);
    if (item != null) {
      item.deleted = true;
      box.put(item);
    }
  }

  static List<LogEvent> getAllOngoing() {
    QueryBuilder<LogEvent> query = box.query(LogEvent_.hasEndTime.equals(true) &
        LogEvent_.endTime.isNull() &
        LogEvent_.deleted.equals(false))
      ..order(LogEvent_.time);
    return query.build().find();
  }

  static List<LogEvent> getAllActiveForTime(DateTime? dateTime) {
    if (dateTime != null) {
      QueryBuilder<LogEvent> builder = box.query(
          LogEvent_.hasEndTime.equals(true) & LogEvent_.deleted.equals(false))
        ..order(LogEvent_.time, flags: Order.descending);
      final eventsWithEndTime = builder.build().find();
      return eventsWithEndTime.where((event) {
        return (!dateTime.isBefore(event.time)) &&
            !dateTime.isAfter(event.endTime ?? DateTime.now());
      }).toList();
    }
    return [];
  }

  static bool eventTypeExistsForTime(int id, DateTime? dateTime) {
    QueryBuilder<LogEvent> builder = box.query(
        LogEvent_.hasEndTime.equals(true) & LogEvent_.deleted.equals(false))
      ..order(LogEvent_.time, flags: Order.descending);
    builder.link(LogEvent_.eventType, LogEventType_.id.equals(id));
    final eventsWithEndTime = builder.build().find();
    if (dateTime != null) {
      return eventsWithEndTime.where((event) {
        return (!dateTime.isBefore(event.time)) &&
            !dateTime.isAfter(event.endTime ?? DateTime.now());
      }).isNotEmpty;
    }
    return eventsWithEndTime.isNotEmpty;
  }

  static List<LogEvent> getAllForDate(DateTime date) {
    DateTime startOfDay = DateTime(date.year, date.month, date.day);
    DateTime endOfDay = startOfDay.add(const Duration(days: 1));

    List<LogEvent> events = [];

    QueryBuilder<LogEvent> allByDate = box
        .query(LogEvent_.deleted.equals(false))
      ..order(LogEvent_.time, flags: Order.descending);
    List<LogEvent> startEvents = allByDate.build().find().where((event) {
      return (event.time.compareTo(startOfDay) >= 0 &&
          event.time.isBefore(endOfDay));
    }).toList();

    for (LogEvent event in startEvents) {
      date = DateTime.utc(event.time.year, event.time.month, event.time.day);
      LogEvent startEvent = event;
      startEvent.title =
          '${event.toString()} ${event.hasEndTime ? '(Start)' : ''}';
      events.add(startEvent);
    }

    QueryBuilder<LogEvent> allByEndDate = box
        .query(LogEvent_.deleted.equals(false).and(LogEvent_.endTime.notNull()))
      ..order(LogEvent_.endTime, flags: Order.descending);
    List<LogEvent> endEvents = allByEndDate.build().find().where((event) {
      return (event.endTime!.compareTo(startOfDay) >= 0 &&
          event.endTime!.isBefore(endOfDay));
    }).toList();

    for (LogEvent event in endEvents) {
      date = DateTime.utc(
          event.endTime!.year, event.endTime!.month, event.endTime!.day);
      LogEvent endEvent = event;
      endEvent.isEndEvent = true;
      endEvent.title = '${event.toString()} (End)';
      events.add(endEvent);
    }

    events.sort((LogEvent a, LogEvent b) {
      final dateA = a.isEndEvent ? a.endTime : a.time;
      final dateB = b.isEndEvent ? b.endTime : b.time;
      return -(dateA!.compareTo(dateB!));
    });

    return events;
  }

  @override
  String toString() {
    return eventType.target?.value ?? '';
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['id'] = id;
    data['deleted'] = deleted;
    data['time'] = time.toIso8601String();
    data['endTime'] = endTime?.toIso8601String();
    data['hasEndTime'] = hasEndTime;
    data['reminderDuration'] = reminderDuration;
    data['notes'] = notes;
    data['eventType'] = eventType.targetId;
    data['bolusProfile'] = bolusProfile.targetId;
    data['basalProfile'] = basalProfile.targetId;
    return data;
  }

   static String? putFromJson(Map<String, dynamic> json, bool overrideExisting, String? source) {
    DateTime? time = DateTime.tryParse(json['time']);

    if (time == null) {
      return 'time is missing';
    }

    final logEvent = LogEvent(
      id: overrideExisting ? json['id'] : 0,
      deleted: json['deleted'],
      time: time,
      endTime: DateTime.tryParse(json['endTime']),
      hasEndTime: json['hasEndTime'],
      reminderDuration: json['reminderDuration'],
      notes: json['notes'],
      source: source,
    );

    logEvent.eventType.targetId = json['eventType'];
    logEvent.bolusProfile.targetId = json['bolusProfile'];
    logEvent.basalProfile.targetId = json['basalProfile'];

    LogEvent.put(logEvent);

    return null;
  }
}