ChickenFarm/UI/CF.APP/chicken_farm/lib/apis/breeding/_submit.dart

import 'package:chicken_farm/core/api/api_option.dart';
import 'package:chicken_farm/core/api/api_service.dart';
import 'package:chicken_farm/core/config/app_config.dart';
import 'package:chicken_farm/core/config/breed_config.dart';
import 'package:chicken_farm/core/db/table_config.dart';
import 'package:chicken_farm/core/services/breeding_data_service.dart';
import 'package:chicken_farm/modes/api/result_model.dart';

class BreedSubmitApi {
  static final BreedSubmitApi _instance = BreedSubmitApi._internal();

  factory BreedSubmitApi() => _instance;

  BreedSubmitApi._internal();
  final BreedingDataService _breedingDataService = BreedingDataService();

  final String bindChickenUrl = '/app/breeding/bind/';
  final String cageChangeUrl = '/app/breeding/cageChange/';
  final String weightUrl = '/app/breeding/weight/';
  final String cullUrl = '/app/breeding/cull/';

  Future<ResultModel> bindChicken(dynamic data) async {
    try {
      List<String> ids = data['rfids'];
      // 保存到本地数据库
      List<Map<String, dynamic>> list = ids.map<Map<String, dynamic>>((id) {
        return {
          'rfid': id,
          'batch_num': data['batchNum'],
          'family_id': data['familyId'],
          'date': data['date'],
          'is_export': 0,
        };
      }).toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline) {
        result = await ApiService().post(
          bindChickenUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(
          TableConfig.chicken,
          list,
        );
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> cageChange(dynamic data) async {
    try {
      final ids = data['rfids'] as List<String>;
      List<Map<String, dynamic>> list = ids.map<Map<String, dynamic>>((id) {
        return {
          'rfid': id,
          'target_cage': data['targetCage'],
          'date': data['date'],
          'is_export': 0,
        };
      }).toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline) {
        result = await ApiService().post(
          cageChangeUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(
          TableConfig.cageChange,
          list,
        );
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> weight(dynamic data) async {
    try {
      Map<String, dynamic> weightData = {
        'rfid': data['rfid'],
        'weight': data['weight'],
        'date': data['date'],
        'is_export': 0,
      };
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline) {
        result = await ApiService().post(
          weightUrl,
          data: weightData,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.insert(
          TableConfig.weight,
          weightData,
        );
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> cull(dynamic data) async {
    try {
      List<Map<String, dynamic>> list = [
        {
          'rfid': data['rfid'],
          'cull_reason': data['cullReason'],
          'disposal_method': data['disposalMethod'],
          'date': data['date'],
          'is_export': 0,
        },
      ];
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline) {
        result = await ApiService().post(
          cullUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(TableConfig.cull, list);
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> batchCull(dynamic data) async {
    try {
      List<String> ids = data['rfids'];
      List<Map<String, dynamic>> list = ids.map<Map<String, dynamic>>((id) {
        return {
          'rfid': id,
          'cull_reason': data['cullReason'],
          'disposal_method': data['disposalMethod'],
          'date': data['date'],
          'is_export': 0,
        };
      }).toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline) {
        result = await ApiService().post(
          cullUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(TableConfig.cull, list);
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> upload(String type, Map<String, dynamic> data) async {
    try {
      if (AppConfig.isOffline) {
        return ResultModel.failOffline("脱机模式不支持调用upload接口");
      }
      String url = getUrl(type);
      if (url.isEmpty) {
        return ResultModel.fail("上传接口不存在");
      }
      return await ApiService().post(
        url,
        data: data,
        apiOption: ApiOption.noAlert(),
      );
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }
}

String getUrl(String type) {
  final prefix = '/app/breeding/';
  switch (type) {
    case BreedConfig.chicken:
      return '${prefix}bindChicken/';
    case BreedConfig.cageChange:
      return '${prefix}cageChange/';
    case BreedConfig.weight:
      return '${prefix}weight/';
    case BreedConfig.cull:
      return '${prefix}cull/';
    default:
      return '';
  }
}