Untitled

import 'dart:async';

import 'dart:developer';

import 'package:dio/dio.dart';
import 'package:get/utils.dart';
import 'package:takamol_user/app/enums/enums.dart';
import 'package:takamol_user/app/server/models/floors.dart';
import 'package:takamol_user/app/server/models/restaurants_orders_items.dart';
import 'package:takamol_user/app/server/server_handlers.dart';
import 'package:takamol_user/app/utils/extensions/duration_parsing.dart';

import '../../../main.dart';
import '../../utils/functions/log.dart';
import '../server_points.dart';
import '../server_response.dart';
import 'guests.dart';
import 'restaurants.dart';
import 'rooms.dart';
import 'users.dart';

class RestaurantOrder {
  /// Important!
  /// * pass an empty string for the [id] if you want to create a new record.
  String id = "";
  String? requesterId = "";
  User? requester;

  //
  int? orderNumber;
  String? waiterId;
  User? waiter;

  //
  String? restaurantId;
  Restaurant? restaurant;

  //
  String? guestId;
  Guest? guest;

  //
  String? floorId;
  Floor? floor;
  String? roomNumber;
  String? roomId;
  String? buildingId;
  Room? room;

  //
  String? instructions;
  OrderStatus status = OrderStatus.none;
  String? statusReason;
  int? canceledBy;
  int? orderType;
  int? reheatingType;
  int? rate;
  int? waiterRate;
  bool? isSkipRate;
  String? rejectedReasonId;
  RejectedReason? rejectedReason;
  String? rejectedOthrReason;
  Duration? estimatedTime;
  String? rateComment;
  DateTime? createdAt;
  DateTime? updatedAt;

  //
  List<RestaurantOrderItem> items = [];
  RestaurantOrder({
    required this.id,
    this.requesterId,
    this.requester,
    this.orderNumber,
    this.waiterId,
    this.waiter,
    this.restaurantId,
    this.restaurant,
    this.guestId,
    this.guest,
    this.floorId,
    this.floor,
    this.roomNumber,
    this.roomId,
    this.buildingId,
    this.room,
    this.instructions,
    this.status = OrderStatus.none,
    this.statusReason,
    this.canceledBy,
    this.orderType,
    this.reheatingType,
    this.rate,
    this.waiterRate,
    this.isSkipRate,
    this.rejectedReasonId,
    this.rejectedReason,
    this.rejectedOthrReason,
    this.estimatedTime,
    this.createdAt,
    this.updatedAt,
    this.rateComment,
    required this.items,
  });

  RestaurantOrder.server({
    this.id = "",
    this.roomId,
    this.buildingId,
    this.floorId,
    this.items = const [],
  });

  factory RestaurantOrder.fromMap(Map<String, dynamic> map) {
    return RestaurantOrder(
      id: returnNullable(map["id"], ""),
      requesterId: returnNullable(map["requesterId"], ""),
      requester: User.tryParse(map["requester"], withUserKey: false),
      orderNumber: returnNullable<int>(map["orderNumber"], 0),
      waiterId: returnNullable<String?>(map["waiterId"], null),
      waiter: User.tryParse(map["waiter"], withUserKey: false),
      restaurantId: returnNullable<String?>(map["restaurantId"], null),
      restaurant: Restaurant.tryParse(map["restaurant"]),
      guestId: returnNullable<String?>(map["guestId"], null),
      guest: Guest.tryParse(map["guest"]),
      floorId: returnNullable<String?>(map["floorId"], null),
      floor: Floor.tryParse(map["floor"]),
      roomNumber: returnNullable<String?>(map["roomNumber"], null),
      roomId: returnNullable<String?>(map["roomId"], null),
      buildingId: returnNullable<String?>(map["buildingId"], null),
      room: Room.tryParse(map["room"]),
      instructions: returnNullable<String?>(map["instructions"], null),
      status: returnNullable<int>(map["status"], 0).toOrderStatus,
      statusReason: returnNullable<String?>(map["statusReason"], null),
      canceledBy: returnNullable<int>(map["canceledBy"], 0),
      orderType: returnNullable<int>(map["orderType"], 0),
      reheatingType: returnNullable<int?>(map["reheatingType"], null),
      rate: returnNullable<int?>(map["rate"], null),
      waiterRate: returnNullable<int?>(map["waiterRate"], null),
      isSkipRate: returnNullable<bool?>(map["isSkipRate"], null),
      rejectedReasonId: returnNullable<String?>(map["rejectedReasonId"], null),
      rejectedReason: RejectedReason.tryParse(map["rejectedReason"]),
      rejectedOthrReason:
          returnNullable<String?>(map["rejectedOthrReason"], null),
      estimatedTime: returnNullable<Duration?>(
          (map["estimatedTime"]?.toString().toDuration()), null),
      rateComment: returnNullable<String?>(map["rateComment"], null),
      createdAt:
          DateTime.tryParse(returnNullable(map["createdAt"], ""))?.toLocal(),
      updatedAt: DateTime.tryParse(returnNullable(map["updatedAt"], "")),
      items: RestaurantOrderItem.tryParseList(map["items"]) ?? [],
    );
  }

  /// for [`POST`] and [`PUT`]
  Map<String, dynamic> toServerMap() {
    var itemsToMap = items.map((e) => e.toServerMap()).toList();
    return {
      if (id.isNotEmpty) "id": id,
      if (roomId != null) "roomId": roomId,
      if (buildingId != null) "buildingId": buildingId,
      if (floorId != null) "floorId": floorId,
      if (reheatingType != null) "reheatingType": reheatingType,
      if (roomNumber != null) "roomNumber": roomNumber,
      if (instructions != null) "instructions": instructions,
      // "status": status,
      "items": itemsToMap,
    };
  }

  Map<String, dynamic> toMap() {
    var itemsToMap = items.map((e) => e.toMap()).toList();
    return {
      if (id.isNotEmpty) "id": id,
      if (requesterId != null) "requesterId": requesterId,
      if (requester != null) "requester": requester!.toMap(withUserKey: false),
      if (orderNumber != null) "orderNumber": orderNumber,
      if (waiterId != null) "waiterId": waiterId,
      if (waiter != null) "waiter": waiter,
      if (restaurantId != null) "restaurantId": restaurantId,
      if (restaurant != null) "restaurant": restaurant!.toMap(),
      if (guestId != null) "guestId": guestId,
      if (guest != null) "guest": guest!.toMap(),
      if (floorId != null) "floorId": floorId,
      if (floor != null) "floor": floor,
      if (roomNumber != null) "roomNumber": roomNumber,
      if (roomId != null) "roomId": roomId,
      if (buildingId != null) "buildingId": buildingId,
      if (room != null) "room": room!.toMap(),
      if (instructions != null) "instructions": instructions,
      "status": status,
      if (statusReason != null) "statusReason": statusReason,
      if (canceledBy != null) "canceledBy": canceledBy,
      if (orderType != null) "orderType": orderType,
      if (reheatingType != null) "reheatingType": reheatingType,
      if (rate != null) "rate": rate,
      if (waiterRate != null) "waiterRate": waiterRate,
      if (isSkipRate != null) "isSkipRate": isSkipRate,
      if (rejectedReasonId != null) "rejectedReasonId": rejectedReasonId,
      if (rejectedReason != null) "rejectedReason": rejectedReason,
      if (rejectedOthrReason != null) "rejectedOthrReason": rejectedOthrReason,
      if (estimatedTime != null) "estimatedTime": estimatedTime,
      if (rateComment != null) "rateComment": rateComment,
      if (itemsToMap.isNotEmpty) "items": itemsToMap,
    };
  }

  Map<String, dynamic> toRatingMap() {
    return {
      if (id.isNotEmpty) "id": id,
      if (rate != null) "rate": rate,
      if (waiterRate != null) "waiterRate": waiterRate,
      if (rateComment != null) "rateComment": rateComment,
    };
  }

  /* Parsers */
  static RestaurantOrder? tryParse(Object? data) {
    return data is Map<String, dynamic> ? RestaurantOrder.fromMap(data) : null;
  }

  static List<RestaurantOrder>? tryParseList(Object? data) {
    List<RestaurantOrder>? fList;
    output(
      name: "List<RestaurantOrder>",
      "tryParseList data type is: ${data.runtimeType}",
    );
    if (data is List/*<Map<String, dynamic>>*/) {
      fList = [];
      for (var listToParse in data) {
        if (listToParse is Map<String, dynamic>) {
          fList.add(RestaurantOrder.fromMap(listToParse));
        }
      }
      return fList;
    }
    return null;
  }
  /* /Parsers */
}

class RejectedReason {
  String? id;
  String? reasonEn;
  String? reasonAr;
  String? reason;
  String? createdAt;
  String? updatedAt;
  bool? isDeleted;

  RejectedReason(
      {this.id,
      this.reasonEn,
      this.reasonAr,
      this.reason,
      this.createdAt,
      this.updatedAt,
      this.isDeleted});

  RejectedReason.fromJson(Map<String, dynamic> json) {
    id = json['id'];
    reasonEn = json['reasonEn'];
    reasonAr = json['reasonAr'];
    reason = json['reason'];
    createdAt = json['createdAt'];
    updatedAt = json['updatedAt'];
    isDeleted = json['isDeleted'];
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['id'] = id;
    data['reasonEn'] = reasonEn;
    data['reasonAr'] = reasonAr;
    data['reason'] = reason;
    data['createdAt'] = createdAt;
    data['updatedAt'] = updatedAt;
    data['isDeleted'] = isDeleted;
    return data;
  }

  static RejectedReason? tryParse(Object? data) {
    return data is Map<String, dynamic> ? RejectedReason.fromJson(data) : null;
  }
}

class RestaurantsOrdersHandler {
  RestaurantsOrdersHandler._();
  static final instance = RestaurantsOrdersHandler._();

  // Restaurants Methods
  Future<ServerResponse<List<RestaurantOrder>?>> get({
    Function(int, int)? onReceiveProgress,
    bool? isMyOrdersOnly,
    bool? isReheating,
    String? status,
    UrlQuery? query,
  }) async {
    try {
      // requesting the data.
      Response<Map<String, dynamic>> dioResponse = await dio.get(
        serverPoints.myRestaurantsOrders + (query?.toUrlQuery ?? ""),
        onReceiveProgress: onReceiveProgress,
        queryParameters: {
          // "isReheating": isReheating,
          // "isMyOrdersOnly": isMyOrdersOnly,
          "status": status,
        },
        options: Options(
          headers: {
            "Authorization": "Bearer ${currentUser?.token}",
            "Accept-Language": Get.locale?.languageCode,
          },
        ),
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      // returning the response.
      print('flf ${dioResponse.realUri}');
      log('flf ${currentUser?.token}');

      return ServerResponse(
        data: RestaurantOrder.tryParseList(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      return ServerResponse.dioError(dioError: e);
    }
  }

  //
  Future<ServerResponse<RestaurantOrder?>> getById({
    required String id,
    Function(int, int)? onReceiveProgress,
  }) async {
    try {
      // requesting the data.
      Response<Map<String, dynamic>> dioResponse = await dio.get(
        serverPoints.restaurantsOrders + id,
        onReceiveProgress: onReceiveProgress,
        options: Options(
          headers: {
            "Authorization": "Bearer ${currentUser?.token}",
            "Accept-Language": Get.locale?.languageCode,
          },
        ),
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      // returning the response.
      return ServerResponse(
        data: RestaurantOrder.tryParse(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      return ServerResponse.dioError(dioError: e);
    }
  }
  //

  Future<ServerResponse<RestaurantOrder?>> reOrder({
    required String id,
    Function(int, int)? onReceiveProgress,
  }) async {
    try {
      // requesting the data.
      Response<Map<String, dynamic>> dioResponse = await dio.post(
        '${serverPoints.restaurantsOrders}$id/reorder',
        onReceiveProgress: onReceiveProgress,
        options: Options(
          headers: {
            "Authorization": "Bearer ${currentUser?.token}",
            "Accept-Language": Get.locale?.languageCode,
          },
        ),
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      // returning the response.
      return ServerResponse(
        data: RestaurantOrder.tryParse(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      return ServerResponse.dioError(dioError: e);
    }
  }
  //

  //
  /// Adds a new record
  Future<ServerResponse<RestaurantOrder?>> add({
    required RestaurantOrder restaurantOrder,
    Function(int, int)? onReceiveProgress,
  }) async {
    try {
      // requesting the data.
      output(restaurantOrder.toServerMap(), name: "restaurant order");

      Response<Map<String, dynamic>> dioResponse = await dio.post(
        serverPoints.restaurantsOrders,
        onReceiveProgress: onReceiveProgress,
        data: restaurantOrder.toServerMap(),
        options: Options(
          headers: {
            "Accept": "application/json",
            "Content-type": "application/json",
            "Authorization": "Bearer ${currentUser?.token}"
          },
        ),
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      return ServerResponse(
        data: RestaurantOrder.tryParse(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      return ServerResponse.dioError(dioError: e);
    }
  }

  //
  /// Cancel a record
  Future<ServerResponse<RestaurantOrder?>> submitRating({
    required RestaurantOrder restaurantOrder,
    Function(int, int)? onReceiveProgress,
  }) async {
    try {
      // requesting the data.
      output(restaurantOrder.toRatingMap(), name: "restaurant order rating");

      Response<Map<String, dynamic>> dioResponse = await dio.put(
        serverPoints.restaurantsOrders,
        onReceiveProgress: onReceiveProgress,
        options: Options(
          headers: {
            "Authorization": "Bearer ${currentUser?.token}",
            "Accept-Language": Get.locale?.languageCode,
          },
        ),
        data: restaurantOrder.toRatingMap(),
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      // returning the response.
      return ServerResponse(
        data: RestaurantOrder.tryParse(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      return ServerResponse.dioError(dioError: e);
    }
  }

  //
  /// Cancel a record
  Future<ServerResponse<RestaurantOrder?>> cancel({
    required String id,
    String? reasonId,
    Function(int, int)? onReceiveProgress,
  }) async {
    try {
      // requesting the data.
      Response<Map<String, dynamic>> dioResponse = await dio.put(
        "${serverPoints.restaurantsOrders}cancel",
        onReceiveProgress: onReceiveProgress,
        options: Options(
          headers: {
            "Authorization": "Bearer ${currentUser?.token}",
            "Accept-Language": Get.locale?.languageCode,
          },
        ),
        data: {
          "orderId": id,
          "reasonId": reasonId,
        },
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      // returning the response.
      return ServerResponse(
        data: RestaurantOrder.tryParse(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      return ServerResponse.dioError(dioError: e);
    }
  }

  /// change record status
  Future<ServerResponse<RestaurantOrder?>> updateStatus({
    required String id,
    required int? status,
    String? statusReason,
    Function(int, int)? onReceiveProgress,
  }) async {
    try {
      // requesting the data.
      Response<Map<String, dynamic>> dioResponse = await dio.put(
        serverPoints.restaurantsOrders,
        onReceiveProgress: onReceiveProgress,
        data: {
          "id": id,
          "status": status,
          // "statusReason": statusReason,
        },
        options: Options(
          headers: {
            "Authorization": "Bearer ${currentUser?.token}",
            "Accept-Language": Get.locale?.languageCode,
          },
        ),
      );
      // handling the data.
      var data = dioResponse.data?["data"];
      // returning the response.
      return ServerResponse(
        data: RestaurantOrder.tryParse(data),
        response: dioResponse,
      );
    } on DioException catch (e) {
      print(e.error);
      return ServerResponse.dioError(dioError: e);
    }
  }
  //
}