collection_remote_datasource.dart

Go to the documentation of this file.

import 'dart:developer';
 
import '../../../../core/api/api_client.dart';
import '../../../../core/api/api_endpoints.dart';
import '../../../../core/services/service_locator.dart';
import '../../../../core/common/models/collection_model.dart';
import '../models/req/req_collection_confirmation_model.dart';
import '../models/req/req_collection_information_model.dart';
import '../models/req/req_collection_payment_model.dart';
import '../models/req/req_collection_rating_model.dart';
import '../models/req/req_collection_validation_model.dart';
import '../models/res/res_cancelation_reason_model.dart';
import '../models/res/res_collection_confirmation_model.dart';
import '../models/res/res_collection_contact_model.dart';
import '../models/res/res_collection_rating_reason_model.dart';
import '../models/res/res_collection_status_model.dart';
import '../models/res/res_collection_information_model.dart';
import '../models/res/res_partner_payment_model.dart';
 
class CollectionsRemoteDataSource {
  final apiClient = sl<ApiClient>();
 
  Future<List<CollectionModel>> getCollections({
    required int userId,
    required bool notForToday,
    required String? type,
  }) async {
    final response = await apiClient.get(
      path: ApiEndpoints.getCollections(
        userId: userId,
        notForToday: notForToday,
        type: type,
      ),
    );
    if (response is List) {
      final collections = response
          .map(
            (json) => CollectionModel.fromJson(json),
          )
          .toList();
      // collections.sort();
      return collections;
    }
    return [];
  }
 
  Future<ResCollectionStatusModel> updateCollectionStatus({
    required int collectionId,
    required String status,
    required String? cancelationReasonId,
  }) async {
    final response = await apiClient.post(
      path: ApiEndpoints.updateCollectionStatus,
      data: {
        'id': collectionId.toString(),
        'status': status,
        if (cancelationReasonId != null)
          'cancelationReason': {
            'id': cancelationReasonId.toString(),
          },
      },
    );
    return ResCollectionStatusModel.fromJson(response);
  }
 
  Future<List<ResCancelationReasonModel>> getCollectionCancelationReasons() async {
    final response = await apiClient.get(path: ApiEndpoints.getCollectionCancelationReasons);
    if (response is List) {
      return response
          .map(
            (json) => ResCancelationReasonModel.fromJson(json),
          )
          .toList();
    }
    return [];
  }
 
  Future<ResCollectionInformationModel> sendCollectionsInformation({
    required ReqCollectionInformationModel reqInformationCollectionModel,
  }) async {
    final response = await apiClient.post(
      path: ApiEndpoints.sendCollectionsInformation,
      data: reqInformationCollectionModel.toJson(),
    );
    return ResCollectionInformationModel.fromJson(response);
  }
 
  Future<void> validateCollection({
    required ReqCollectionValidationModel reqValidationCollectionModel,
  }) async {
    final test = await apiClient.post(
      path: ApiEndpoints.validateCollection,
      data: reqValidationCollectionModel.toJson(),
    );
    log(test.toString());
  }
 
  Future<ResCollectionConfirmationModel> sendCollectionConfirmation({
    required ReqCollectionConfirmationModel reqCollectionConfirmationModel,
  }) async {
    final response = await apiClient.post(
      path: ApiEndpoints.sendCollectionConfirmation,
      data: reqCollectionConfirmationModel.toJson(),
    );
    return ResCollectionConfirmationModel.fromJson(response);
  }
 
  Future<void> sendCollectionPayment({
    required ReqCollectionPaymentModel reqCollectionPaymentModel,
  }) async {
    final response = await apiClient.post(
      path: ApiEndpoints.sendCollectionPayment,
      data: reqCollectionPaymentModel.toJson(),
    );
    return response['success'];
  }
 
  Future<void> sendCollectionRating({
    required ReqCollectionRatingModel reqCollectionRatingModel,
  }) async {
    final response = await apiClient.post(
      path: ApiEndpoints.sendCollectionRating,
      data: reqCollectionRatingModel.toJson(),
    );
    return response['success'];
  }
 
  Future<List<ResCollectionContactModel>> getCollectionContactList({
    required int restaurentId,
  }) async {
    final response = await apiClient.get(
      path: ApiEndpoints.getCollectionContactList(
        restaurentId: restaurentId,
      ),
    );
    if (response is List) {
      return response.map(
        (json) => ResCollectionContactModel.fromJson(json),
      ).toList();
    }
    return [];
  }
 
  Future<List<ResCollectionRatingReasonModel>> getRatingReasons() async {
    final response = await apiClient.get(path: ApiEndpoints.ratingReasons);
    if (response is List) {
      return response
          .map(
            (json) => ResCollectionRatingReasonModel.fromJson(json),
          )
          .toList();
    }
    return [];
  }
 
  Future<List<ResPartnerPaymentModel>> getCollectionPaymentModeList({
    required int restaurentId,
  }) async {
    final response = await apiClient.get(
      path: ApiEndpoints.getCollectionPaymentModeList(
        restaurentId: restaurentId,
      ),
    );
    if (response is List) {
      final paymentModes = response.map(
        (json) => ResPartnerPaymentModel.fromJson(json),
      ).toList();
      return paymentModes;
    }
    return [];
  }
}