mobile-app/lib/data/repository/repository.dart

import 'package:dio/dio.dart';
import 'package:dio_http_cache/dio_http_cache.dart';
import 'package:farm_tpf/custom_model/ActionType.dart';
import 'package:farm_tpf/custom_model/CropPlot.dart';
import 'package:farm_tpf/custom_model/Device.dart';
import 'package:farm_tpf/custom_model/EnvironmentParameter.dart';
import 'package:farm_tpf/custom_model/Harvest.dart';
import 'package:farm_tpf/custom_model/LocationUnit.dart';
import 'package:farm_tpf/custom_model/NotificationObjectDTO.dart';
import 'package:farm_tpf/custom_model/Supply.dart';
import 'package:farm_tpf/custom_model/TbCropDTO.dart';
import 'package:farm_tpf/custom_model/UpdateNoti.dart';
import 'package:farm_tpf/custom_model/WaterType.dart';
import 'package:farm_tpf/custom_model/action_form/ActionUIForm.dart';
import 'package:farm_tpf/custom_model/action_form/CommonData.dart';
import 'package:farm_tpf/custom_model/action_form/RequestActivity.dart';
import 'package:farm_tpf/custom_model/user.dart';
import 'package:farm_tpf/custom_model/user_request.dart';
import 'package:farm_tpf/data/api/dio_provider.dart';
import 'package:farm_tpf/data/api/rest_client.dart';
import 'package:farm_tpf/models/PagedResult.dart';
import 'package:farm_tpf/utils/const_common.dart';
import 'package:flutter/material.dart';

class Repository {
  final dio = DioProvider.instance();

  Future<List<ActionType>> getActionTypes() {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    return client.getActionTypes(options: op);
  }

  Future<List<Harvest>> getHarvests() {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    return client.getHarvests(options: op);
  }

  Future<List<WaterType>> getWaterTypes() {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    return client.getWaterTypes(options: op);
  }

  Future<CropPlot> getPlotDetail(int cropId, {int page, int size}) {
    final client = RestClient(dio);
    return client.getCropDetail(cropId, page: page, size: size);
  }

  Future<CropPlot> getPlotDetailByCode(String cropCode, {int page, int size}) {
    final client = RestClient(dio);
    return client.getCropDetailByCode(cropCode, page: page, size: size);
  }

  Future<List<TbCropDTO>> getPlots({int page, int size, String searchString}) {
    final client = RestClient(dio);
    return client.getPlots(page: page, size: size, query: searchString);
  }

  Future<void> updatePlot(TbCropDTO tbCropDTO) {
    final client = RestClient(dio);
    return client.updateCrop(tbCropDTO);
  }

  Future<User> signInWithCredentials(String username, String password) {
    final client = RestClient(dio);
    return client.login(UserRequest(username: username, password: password));
  }

  Future<PagedResult<T>> getInfinityList<T>(String url,
      {int page = 0, int size = 20}) async {
    var initUrl = "/api/activities/latest-env-by-activity-type/1/2";
    var url =
        ConstCommon.baseUrl + initUrl + "?page=$page&paged=true&size=$size";
    var response = await dio.get(url);

    final value = PagedResult<T>.fromJson(response.data, getInstanceClass());
    return value;
  }

  Future<List<Supply>> getSupplies(String type, {String query = ""}) async {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    return client.getSupplies(type, query: query, options: op);
  }

  Future<List<Device>> getDeviceForActivity() async {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    return client.getDeviceForActivity(options: op);
  }

  Future<void> updateAllNotification(String status) {
    final client = RestClient(dio);
    return client.updateAllNotification(status);
  }

  Future<void> updateNoti(UpdateNoti updateNoti) {
    final client = RestClient(dio);
    return client.updateNoti(updateNoti);
  }

  Future<NotificationObjectDTO> getNotifications(
      {int page = 0, int size = 20}) async {
    var url = ConstCommon.baseUrl +
        "/api/notifications-current-user?page=$page&size=$size&sort=sendDate,DESC";
    var response = await dio.get(url);

    final value = NotificationObjectDTO.fromJson(response.data);
    return value;
  }

  Future<List<LocationUnit>> getLocationUnits(
      {@required LocationType locationType,
      int filterId,
      int page = 0,
      int size = 500,
      String query = ''}) {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    var response;
    switch (locationType) {
      case LocationType.province:
        response = client.getProvinces(filterId,
            options: op, page: page, size: size, query: query);
        break;
      case LocationType.district:
        response = client.getDistricts(filterId,
            options: op, page: page, size: size, query: query);
        break;
      case LocationType.ward:
        response = client.getWards(filterId,
            options: op, page: page, size: size, query: query);
        break;
      default:
        response = client.getCountries(query: query);
    }
    return response;
  }

  Object getInstanceClass() {
    var instanceClass;
    if (1 == 1) {
      instanceClass = new TbCropDTO();
    }
    return instanceClass;
  }

  //Action
  Future<void> createAction(
      Function(dynamic) onSuccess, Function(dynamic) onError,
      {String apiAddAction,
      String paramActivity,
      String activityAction,
      List<String> filePaths}) async {
    var formData = FormData();
    filePaths.forEach((f) {
      formData.files.add(MapEntry("images", MultipartFile.fromFileSync(f)));
    });
    formData.fields.add(MapEntry(paramActivity, activityAction));
    try {
      await dio
          .post("${ConstCommon.baseUrl}/$apiAddAction", data: formData)
          .then((value) {
        onSuccess(value.data);
      });
    } on DioError catch (e) {
      onError(e);
    }
  }

  Future<void> updateAction(
      Function(dynamic) onSuccess, Function(dynamic) onError,
      {String apiUpdateAction,
      String paramActivity,
      String activityAction,
      List<String> filePaths}) async {
    var formData = FormData();
    filePaths.forEach((f) {
      formData.files.add(MapEntry("images", MultipartFile.fromFileSync(f)));
    });
    formData.fields.add(MapEntry(paramActivity, activityAction));
    try {
      await dio
          .post("${ConstCommon.baseUrl}/$apiUpdateAction", data: formData)
          .then((value) {
        onSuccess(value.data);
      });
    } on DioError catch (e) {
      onError(e);
    }
  }

  //Device
  Future<List<Device>> getDevices(String query) {
    final client = RestClient(dio);
    return client.getDevices(query: query);
  }

  //Environment Parameter
  Future<List<EnvironmentParameter>> getEnvironmentParameters(
      {@required int cropId, int page, int size}) {
    final client = RestClient(dio);
    return client.getEnvironmentParameters(cropId, page: page, size: size);
  }

  //NEW IMPLEMENT
  Future<void> allActionTypes(int cropTypeId,
      Function(List<ActionType>) onSuccess, Function(dynamic) onError) async {
    try {
      var url =
          '${ConstCommon.baseUrl}/api/listActivityTypesCulture/$cropTypeId';

      final Response<List<dynamic>> _result = await dio.get(url);
      var value = _result.data
          .map((dynamic i) => ActionType.fromJson(i as Map<String, dynamic>))
          .toList();
      onSuccess(value);
    } on DioError catch (e) {
      onError(e);
    }
  }

  Future<ActionUIForm> getActionUIForm({@required int idAction}) {
    final client = RestClient(dio);
    var op = buildConfigurableCacheOptions(
        forceRefresh: true, maxAge: Duration(days: ConstCommon.kMaxAgeCache));
    return client.getActionUIForm(idAction, op);
  }

  Future<List<CommonData>> getCommonData(
      {String tableSupply, String condition}) async {
    var url =
        '${ConstCommon.baseUrl}/api/get-data-from-table-common?tableName=$tableSupply&condition=$condition';

    final Response<List<dynamic>> _result = await dio.get(url);
    var value = _result.data
        .map((dynamic i) => CommonData.fromJson(i as Map<String, dynamic>))
        .toList();
    return value;
  }

  Future<void> createActionCommon(
      Function(dynamic) onSuccess, Function(dynamic) onError,
      {@required String activityType,
      @required String activityData,
      List<String> filePaths}) async {
    var formData = FormData();
    filePaths.forEach((f) {
      formData.files.add(MapEntry('images', MultipartFile.fromFileSync(f)));
    });
    formData.fields.add(MapEntry('tbCommonActivityDTO', activityData));
    try {
      await dio
          .post(
              "${ConstCommon.baseUrl}/api/create-common-activity/$activityType",
              data: formData)
          .then((value) {
        onSuccess(value.data);
      });
    } on DioError catch (e) {
      onError(e);
    }
  }

  Future<void> updateActionCommon(
      Function(dynamic) onSuccess, Function(dynamic) onError,
      {String activityType,
      String activityAction,
      List<String> filePaths}) async {
    var formData = FormData();
    filePaths.forEach((f) {
      formData.files.add(MapEntry('images', MultipartFile.fromFileSync(f)));
    });
    formData.fields.add(MapEntry('tbCommonActivityDTO', activityAction));
    try {
      await dio
          .put(
              "${ConstCommon.baseUrl}/api/update-common-activity/$activityType",
              data: formData)
          .then((value) {
        onSuccess(value.data);
      });
    } on DioError catch (e) {
      onError(e);
    }
  }

  Future<RequestActivity> detailCommonAction(
      {@required int activityId, @required String activityType}) async {
    final client = RestClient(dio);
    return client.getDetailActivityCommon(
        actionType: activityType, activityId: activityId);
  }
}