runable

lib/core/database/models/cached_data.dart

@@ -0,0 +1,79 @@
+import 'package:hive_ce/hive.dart';
+
+import 'package:worker/core/constants/storage_constants.dart';
+
+part 'cached_data.g.dart';
+
+/// Cached Data Model
+///
+/// Wrapper for caching API responses with timestamp and expiration.
+/// Used for offline-first functionality and reducing API calls.
+///
+/// Example usage:
+/// ```dart
+/// final cachedProducts = CachedData(
+///   data: products,
+///   lastUpdated: DateTime.now(),
+/// );
+/// ```
+@HiveType(typeId: HiveTypeIds.cachedData)
+class CachedData extends HiveObject {
+  CachedData({
+    required this.data,
+    required this.lastUpdated,
+    this.expiresAt,
+    this.source,
+  });
+
+  /// The cached data (stored as dynamic)
+  @HiveField(0)
+  final dynamic data;
+
+  /// When the data was last updated
+  @HiveField(1)
+  final DateTime lastUpdated;
+
+  /// Optional expiration time
+  @HiveField(2)
+  final DateTime? expiresAt;
+
+  /// Source of the data (e.g., 'api', 'local')
+  @HiveField(3)
+  final String? source;
+
+  /// Check if cache is expired
+  bool get isExpired {
+    if (expiresAt == null) return false;
+    return DateTime.now().isAfter(expiresAt!);
+  }
+
+  /// Check if cache is fresh (not expired and within max age)
+  bool isFresh(Duration maxAge) {
+    if (isExpired) return false;
+    final age = DateTime.now().difference(lastUpdated);
+    return age <= maxAge;
+  }
+
+  /// Get age of cached data
+  Duration get age => DateTime.now().difference(lastUpdated);
+
+  /// Create a copy with updated data
+  CachedData copyWith({
+    dynamic data,
+    DateTime? lastUpdated,
+    DateTime? expiresAt,
+    String? source,
+  }) {
+    return CachedData(
+      data: data ?? this.data,
+      lastUpdated: lastUpdated ?? this.lastUpdated,
+      expiresAt: expiresAt ?? this.expiresAt,
+      source: source ?? this.source,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'CachedData(lastUpdated: $lastUpdated, expiresAt: $expiresAt, source: $source, isExpired: $isExpired)';
+  }
+}

lib/core/database/models/cached_data.g.dart

@@ -0,0 +1,50 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'cached_data.dart';
+
+// **************************************************************************
+// TypeAdapterGenerator
+// **************************************************************************
+
+class CachedDataAdapter extends TypeAdapter<CachedData> {
+  @override
+  final typeId = 30;
+
+  @override
+  CachedData read(BinaryReader reader) {
+    final numOfFields = reader.readByte();
+    final fields = <int, dynamic>{
+      for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(),
+    };
+    return CachedData(
+      data: fields[0] as dynamic,
+      lastUpdated: fields[1] as DateTime,
+      expiresAt: fields[2] as DateTime?,
+      source: fields[3] as String?,
+    );
+  }
+
+  @override
+  void write(BinaryWriter writer, CachedData obj) {
+    writer
+      ..writeByte(4)
+      ..writeByte(0)
+      ..write(obj.data)
+      ..writeByte(1)
+      ..write(obj.lastUpdated)
+      ..writeByte(2)
+      ..write(obj.expiresAt)
+      ..writeByte(3)
+      ..write(obj.source);
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is CachedDataAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}

lib/core/database/models/enums.dart

@@ -0,0 +1,425 @@
+import 'package:hive_ce/hive.dart';
+
+import 'package:worker/core/constants/storage_constants.dart';
+
+part 'enums.g.dart';
+
+/// Member Tier Levels
+///
+/// Represents the loyalty program membership tiers.
+/// Higher tiers receive more benefits and rewards.
+@HiveType(typeId: HiveTypeIds.memberTier)
+enum MemberTier {
+  /// Gold tier - Entry level membership
+  @HiveField(0)
+  gold,
+
+  /// Platinum tier - Mid-level membership
+  @HiveField(1)
+  platinum,
+
+  /// Diamond tier - Premium membership
+  @HiveField(2)
+  diamond,
+}
+
+/// User Type Categories
+///
+/// Represents the different types of users in the app.
+@HiveType(typeId: HiveTypeIds.userType)
+enum UserType {
+  /// Construction contractor
+  @HiveField(0)
+  contractor,
+
+  /// Architect or designer
+  @HiveField(1)
+  architect,
+
+  /// Product distributor
+  @HiveField(2)
+  distributor,
+
+  /// Real estate broker
+  @HiveField(3)
+  broker,
+}
+
+/// Order Status
+///
+/// Represents the current state of an order.
+@HiveType(typeId: HiveTypeIds.orderStatus)
+enum OrderStatus {
+  /// Order placed, awaiting confirmation
+  @HiveField(0)
+  pending,
+
+  /// Order confirmed and being processed
+  @HiveField(1)
+  processing,
+
+  /// Order is being shipped/delivered
+  @HiveField(2)
+  shipping,
+
+  /// Order completed successfully
+  @HiveField(3)
+  completed,
+
+  /// Order cancelled
+  @HiveField(4)
+  cancelled,
+
+  /// Order refunded
+  @HiveField(5)
+  refunded,
+}
+
+/// Project Status
+///
+/// Represents the current state of a construction project.
+@HiveType(typeId: HiveTypeIds.projectStatus)
+enum ProjectStatus {
+  /// Project in planning phase
+  @HiveField(0)
+  planning,
+
+  /// Project actively in progress
+  @HiveField(1)
+  inProgress,
+
+  /// Project on hold
+  @HiveField(2)
+  onHold,
+
+  /// Project completed
+  @HiveField(3)
+  completed,
+
+  /// Project cancelled
+  @HiveField(4)
+  cancelled,
+}
+
+/// Project Type
+///
+/// Represents the category of construction project.
+@HiveType(typeId: HiveTypeIds.projectType)
+enum ProjectType {
+  /// Residential building project
+  @HiveField(0)
+  residential,
+
+  /// Commercial building project
+  @HiveField(1)
+  commercial,
+
+  /// Industrial facility project
+  @HiveField(2)
+  industrial,
+
+  /// Infrastructure project
+  @HiveField(3)
+  infrastructure,
+
+  /// Renovation project
+  @HiveField(4)
+  renovation,
+}
+
+/// Loyalty Transaction Type
+///
+/// Represents the type of loyalty points transaction.
+@HiveType(typeId: HiveTypeIds.transactionType)
+enum TransactionType {
+  /// Points earned from purchase
+  @HiveField(0)
+  earnedPurchase,
+
+  /// Points earned from referral
+  @HiveField(1)
+  earnedReferral,
+
+  /// Points earned from promotion
+  @HiveField(2)
+  earnedPromotion,
+
+  /// Bonus points from admin
+  @HiveField(3)
+  earnedBonus,
+
+  /// Points redeemed for reward
+  @HiveField(4)
+  redeemedReward,
+
+  /// Points redeemed for discount
+  @HiveField(5)
+  redeemedDiscount,
+
+  /// Points adjusted by admin
+  @HiveField(6)
+  adjustment,
+
+  /// Points expired
+  @HiveField(7)
+  expired,
+}
+
+/// Gift Status
+///
+/// Represents the status of a redeemed gift/reward.
+@HiveType(typeId: HiveTypeIds.giftStatus)
+enum GiftStatus {
+  /// Gift is active and can be used
+  @HiveField(0)
+  active,
+
+  /// Gift has been used
+  @HiveField(1)
+  used,
+
+  /// Gift has expired
+  @HiveField(2)
+  expired,
+
+  /// Gift is reserved but not activated
+  @HiveField(3)
+  reserved,
+
+  /// Gift has been cancelled
+  @HiveField(4)
+  cancelled,
+}
+
+/// Payment Status
+///
+/// Represents the status of a payment transaction.
+@HiveType(typeId: HiveTypeIds.paymentStatus)
+enum PaymentStatus {
+  /// Payment pending
+  @HiveField(0)
+  pending,
+
+  /// Payment being processed
+  @HiveField(1)
+  processing,
+
+  /// Payment completed successfully
+  @HiveField(2)
+  completed,
+
+  /// Payment failed
+  @HiveField(3)
+  failed,
+
+  /// Payment refunded
+  @HiveField(4)
+  refunded,
+
+  /// Payment cancelled
+  @HiveField(5)
+  cancelled,
+}
+
+/// Notification Type
+///
+/// Represents different categories of notifications.
+@HiveType(typeId: HiveTypeIds.notificationType)
+enum NotificationType {
+  /// Order-related notification
+  @HiveField(0)
+  order,
+
+  /// Promotion or offer notification
+  @HiveField(1)
+  promotion,
+
+  /// System announcement
+  @HiveField(2)
+  system,
+
+  /// Loyalty program notification
+  @HiveField(3)
+  loyalty,
+
+  /// Project-related notification
+  @HiveField(4)
+  project,
+
+  /// Payment notification
+  @HiveField(5)
+  payment,
+
+  /// General message
+  @HiveField(6)
+  message,
+}
+
+/// Payment Method
+///
+/// Represents available payment methods.
+@HiveType(typeId: HiveTypeIds.paymentMethod)
+enum PaymentMethod {
+  /// Cash on delivery
+  @HiveField(0)
+  cashOnDelivery,
+
+  /// Bank transfer
+  @HiveField(1)
+  bankTransfer,
+
+  /// Credit/Debit card
+  @HiveField(2)
+  card,
+
+  /// E-wallet (Momo, ZaloPay, etc.)
+  @HiveField(3)
+  eWallet,
+
+  /// QR code payment
+  @HiveField(4)
+  qrCode,
+
+  /// Pay later / Credit
+  @HiveField(5)
+  payLater,
+}
+
+/// Extension methods for enums
+
+extension MemberTierExtension on MemberTier {
+  /// Get display name
+  String get displayName {
+    switch (this) {
+      case MemberTier.gold:
+        return 'Gold';
+      case MemberTier.platinum:
+        return 'Platinum';
+      case MemberTier.diamond:
+        return 'Diamond';
+    }
+  }
+
+  /// Get tier level (higher is better)
+  int get level {
+    switch (this) {
+      case MemberTier.gold:
+        return 1;
+      case MemberTier.platinum:
+        return 2;
+      case MemberTier.diamond:
+        return 3;
+    }
+  }
+}
+
+extension UserTypeExtension on UserType {
+  /// Get display name (Vietnamese)
+  String get displayName {
+    switch (this) {
+      case UserType.contractor:
+        return 'Thầu thợ';
+      case UserType.architect:
+        return 'Kiến trúc sư';
+      case UserType.distributor:
+        return 'Đại lý phân phối';
+      case UserType.broker:
+        return 'Môi giới';
+    }
+  }
+}
+
+extension OrderStatusExtension on OrderStatus {
+  /// Get display name (Vietnamese)
+  String get displayName {
+    switch (this) {
+      case OrderStatus.pending:
+        return 'Chờ xác nhận';
+      case OrderStatus.processing:
+        return 'Đang xử lý';
+      case OrderStatus.shipping:
+        return 'Đang giao hàng';
+      case OrderStatus.completed:
+        return 'Hoàn thành';
+      case OrderStatus.cancelled:
+        return 'Đã hủy';
+      case OrderStatus.refunded:
+        return 'Đã hoàn tiền';
+    }
+  }
+
+  /// Check if order is active
+  bool get isActive {
+    return this == OrderStatus.pending ||
+        this == OrderStatus.processing ||
+        this == OrderStatus.shipping;
+  }
+
+  /// Check if order is final
+  bool get isFinal {
+    return this == OrderStatus.completed ||
+        this == OrderStatus.cancelled ||
+        this == OrderStatus.refunded;
+  }
+}
+
+extension ProjectStatusExtension on ProjectStatus {
+  /// Get display name (Vietnamese)
+  String get displayName {
+    switch (this) {
+      case ProjectStatus.planning:
+        return 'Lập kế hoạch';
+      case ProjectStatus.inProgress:
+        return 'Đang thực hiện';
+      case ProjectStatus.onHold:
+        return 'Tạm dừng';
+      case ProjectStatus.completed:
+        return 'Hoàn thành';
+      case ProjectStatus.cancelled:
+        return 'Đã hủy';
+    }
+  }
+
+  /// Check if project is active
+  bool get isActive {
+    return this == ProjectStatus.planning || this == ProjectStatus.inProgress;
+  }
+}
+
+extension TransactionTypeExtension on TransactionType {
+  /// Check if transaction is earning points
+  bool get isEarning {
+    return this == TransactionType.earnedPurchase ||
+        this == TransactionType.earnedReferral ||
+        this == TransactionType.earnedPromotion ||
+        this == TransactionType.earnedBonus;
+  }
+
+  /// Check if transaction is spending points
+  bool get isSpending {
+    return this == TransactionType.redeemedReward ||
+        this == TransactionType.redeemedDiscount;
+  }
+
+  /// Get display name (Vietnamese)
+  String get displayName {
+    switch (this) {
+      case TransactionType.earnedPurchase:
+        return 'Mua hàng';
+      case TransactionType.earnedReferral:
+        return 'Giới thiệu bạn bè';
+      case TransactionType.earnedPromotion:
+        return 'Khuyến mãi';
+      case TransactionType.earnedBonus:
+        return 'Thưởng';
+      case TransactionType.redeemedReward:
+        return 'Đổi quà';
+      case TransactionType.redeemedDiscount:
+        return 'Đổi giảm giá';
+      case TransactionType.adjustment:
+        return 'Điều chỉnh';
+      case TransactionType.expired:
+        return 'Hết hạn';
+    }
+  }
+}

lib/core/database/models/enums.g.dart

@@ -0,0 +1,517 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'enums.dart';
+
+// **************************************************************************
+// TypeAdapterGenerator
+// **************************************************************************
+
+class MemberTierAdapter extends TypeAdapter<MemberTier> {
+  @override
+  final typeId = 20;
+
+  @override
+  MemberTier read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return MemberTier.gold;
+      case 1:
+        return MemberTier.platinum;
+      case 2:
+        return MemberTier.diamond;
+      default:
+        return MemberTier.gold;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, MemberTier obj) {
+    switch (obj) {
+      case MemberTier.gold:
+        writer.writeByte(0);
+      case MemberTier.platinum:
+        writer.writeByte(1);
+      case MemberTier.diamond:
+        writer.writeByte(2);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is MemberTierAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class UserTypeAdapter extends TypeAdapter<UserType> {
+  @override
+  final typeId = 21;
+
+  @override
+  UserType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return UserType.contractor;
+      case 1:
+        return UserType.architect;
+      case 2:
+        return UserType.distributor;
+      case 3:
+        return UserType.broker;
+      default:
+        return UserType.contractor;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, UserType obj) {
+    switch (obj) {
+      case UserType.contractor:
+        writer.writeByte(0);
+      case UserType.architect:
+        writer.writeByte(1);
+      case UserType.distributor:
+        writer.writeByte(2);
+      case UserType.broker:
+        writer.writeByte(3);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is UserTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class OrderStatusAdapter extends TypeAdapter<OrderStatus> {
+  @override
+  final typeId = 22;
+
+  @override
+  OrderStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return OrderStatus.pending;
+      case 1:
+        return OrderStatus.processing;
+      case 2:
+        return OrderStatus.shipping;
+      case 3:
+        return OrderStatus.completed;
+      case 4:
+        return OrderStatus.cancelled;
+      case 5:
+        return OrderStatus.refunded;
+      default:
+        return OrderStatus.pending;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, OrderStatus obj) {
+    switch (obj) {
+      case OrderStatus.pending:
+        writer.writeByte(0);
+      case OrderStatus.processing:
+        writer.writeByte(1);
+      case OrderStatus.shipping:
+        writer.writeByte(2);
+      case OrderStatus.completed:
+        writer.writeByte(3);
+      case OrderStatus.cancelled:
+        writer.writeByte(4);
+      case OrderStatus.refunded:
+        writer.writeByte(5);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is OrderStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class ProjectStatusAdapter extends TypeAdapter<ProjectStatus> {
+  @override
+  final typeId = 23;
+
+  @override
+  ProjectStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return ProjectStatus.planning;
+      case 1:
+        return ProjectStatus.inProgress;
+      case 2:
+        return ProjectStatus.onHold;
+      case 3:
+        return ProjectStatus.completed;
+      case 4:
+        return ProjectStatus.cancelled;
+      default:
+        return ProjectStatus.planning;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, ProjectStatus obj) {
+    switch (obj) {
+      case ProjectStatus.planning:
+        writer.writeByte(0);
+      case ProjectStatus.inProgress:
+        writer.writeByte(1);
+      case ProjectStatus.onHold:
+        writer.writeByte(2);
+      case ProjectStatus.completed:
+        writer.writeByte(3);
+      case ProjectStatus.cancelled:
+        writer.writeByte(4);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ProjectStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class ProjectTypeAdapter extends TypeAdapter<ProjectType> {
+  @override
+  final typeId = 24;
+
+  @override
+  ProjectType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return ProjectType.residential;
+      case 1:
+        return ProjectType.commercial;
+      case 2:
+        return ProjectType.industrial;
+      case 3:
+        return ProjectType.infrastructure;
+      case 4:
+        return ProjectType.renovation;
+      default:
+        return ProjectType.residential;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, ProjectType obj) {
+    switch (obj) {
+      case ProjectType.residential:
+        writer.writeByte(0);
+      case ProjectType.commercial:
+        writer.writeByte(1);
+      case ProjectType.industrial:
+        writer.writeByte(2);
+      case ProjectType.infrastructure:
+        writer.writeByte(3);
+      case ProjectType.renovation:
+        writer.writeByte(4);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ProjectTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class TransactionTypeAdapter extends TypeAdapter<TransactionType> {
+  @override
+  final typeId = 25;
+
+  @override
+  TransactionType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return TransactionType.earnedPurchase;
+      case 1:
+        return TransactionType.earnedReferral;
+      case 2:
+        return TransactionType.earnedPromotion;
+      case 3:
+        return TransactionType.earnedBonus;
+      case 4:
+        return TransactionType.redeemedReward;
+      case 5:
+        return TransactionType.redeemedDiscount;
+      case 6:
+        return TransactionType.adjustment;
+      case 7:
+        return TransactionType.expired;
+      default:
+        return TransactionType.earnedPurchase;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, TransactionType obj) {
+    switch (obj) {
+      case TransactionType.earnedPurchase:
+        writer.writeByte(0);
+      case TransactionType.earnedReferral:
+        writer.writeByte(1);
+      case TransactionType.earnedPromotion:
+        writer.writeByte(2);
+      case TransactionType.earnedBonus:
+        writer.writeByte(3);
+      case TransactionType.redeemedReward:
+        writer.writeByte(4);
+      case TransactionType.redeemedDiscount:
+        writer.writeByte(5);
+      case TransactionType.adjustment:
+        writer.writeByte(6);
+      case TransactionType.expired:
+        writer.writeByte(7);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is TransactionTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class GiftStatusAdapter extends TypeAdapter<GiftStatus> {
+  @override
+  final typeId = 26;
+
+  @override
+  GiftStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return GiftStatus.active;
+      case 1:
+        return GiftStatus.used;
+      case 2:
+        return GiftStatus.expired;
+      case 3:
+        return GiftStatus.reserved;
+      case 4:
+        return GiftStatus.cancelled;
+      default:
+        return GiftStatus.active;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, GiftStatus obj) {
+    switch (obj) {
+      case GiftStatus.active:
+        writer.writeByte(0);
+      case GiftStatus.used:
+        writer.writeByte(1);
+      case GiftStatus.expired:
+        writer.writeByte(2);
+      case GiftStatus.reserved:
+        writer.writeByte(3);
+      case GiftStatus.cancelled:
+        writer.writeByte(4);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is GiftStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class PaymentStatusAdapter extends TypeAdapter<PaymentStatus> {
+  @override
+  final typeId = 27;
+
+  @override
+  PaymentStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return PaymentStatus.pending;
+      case 1:
+        return PaymentStatus.processing;
+      case 2:
+        return PaymentStatus.completed;
+      case 3:
+        return PaymentStatus.failed;
+      case 4:
+        return PaymentStatus.refunded;
+      case 5:
+        return PaymentStatus.cancelled;
+      default:
+        return PaymentStatus.pending;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, PaymentStatus obj) {
+    switch (obj) {
+      case PaymentStatus.pending:
+        writer.writeByte(0);
+      case PaymentStatus.processing:
+        writer.writeByte(1);
+      case PaymentStatus.completed:
+        writer.writeByte(2);
+      case PaymentStatus.failed:
+        writer.writeByte(3);
+      case PaymentStatus.refunded:
+        writer.writeByte(4);
+      case PaymentStatus.cancelled:
+        writer.writeByte(5);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is PaymentStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class NotificationTypeAdapter extends TypeAdapter<NotificationType> {
+  @override
+  final typeId = 28;
+
+  @override
+  NotificationType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return NotificationType.order;
+      case 1:
+        return NotificationType.promotion;
+      case 2:
+        return NotificationType.system;
+      case 3:
+        return NotificationType.loyalty;
+      case 4:
+        return NotificationType.project;
+      case 5:
+        return NotificationType.payment;
+      case 6:
+        return NotificationType.message;
+      default:
+        return NotificationType.order;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, NotificationType obj) {
+    switch (obj) {
+      case NotificationType.order:
+        writer.writeByte(0);
+      case NotificationType.promotion:
+        writer.writeByte(1);
+      case NotificationType.system:
+        writer.writeByte(2);
+      case NotificationType.loyalty:
+        writer.writeByte(3);
+      case NotificationType.project:
+        writer.writeByte(4);
+      case NotificationType.payment:
+        writer.writeByte(5);
+      case NotificationType.message:
+        writer.writeByte(6);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is NotificationTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class PaymentMethodAdapter extends TypeAdapter<PaymentMethod> {
+  @override
+  final typeId = 29;
+
+  @override
+  PaymentMethod read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return PaymentMethod.cashOnDelivery;
+      case 1:
+        return PaymentMethod.bankTransfer;
+      case 2:
+        return PaymentMethod.card;
+      case 3:
+        return PaymentMethod.eWallet;
+      case 4:
+        return PaymentMethod.qrCode;
+      case 5:
+        return PaymentMethod.payLater;
+      default:
+        return PaymentMethod.cashOnDelivery;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, PaymentMethod obj) {
+    switch (obj) {
+      case PaymentMethod.cashOnDelivery:
+        writer.writeByte(0);
+      case PaymentMethod.bankTransfer:
+        writer.writeByte(1);
+      case PaymentMethod.card:
+        writer.writeByte(2);
+      case PaymentMethod.eWallet:
+        writer.writeByte(3);
+      case PaymentMethod.qrCode:
+        writer.writeByte(4);
+      case PaymentMethod.payLater:
+        writer.writeByte(5);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is PaymentMethodAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}