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/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();

  Future<ResultModel> bindChicken(dynamic data) async {
    try {
      if (AppConfig.isOffline) {
        return await bindChickenOffline(data);
      } else {
        return await ApiService().postWithOfflineSupport(
          '/app/breeding/create/',
          data: data,
          apiOption: ApiOption.noAlert(),
        );
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> bindChickenOffline(dynamic data) async {
    // 保存到本地数据库
    List<Map<String, dynamic>> list = data.map<Map<String, dynamic>>((item) {
      return {
        'rfid': item['rfid'],
        'batch_num': item['batchNum'],
        'family_id': item['familyId'],
        'date': item['date'],
        'is_export': 0,
      };
    }).toList();
    if (await BreedingDataService().batchInsertChicken(list)) {
      return ResultModel.success('数据保存成功');
    } else {
      return ResultModel.fail('数据保存失败');
    }
  }

  Future<ResultModel> cageChange(dynamic data) async {
    try {
      if (AppConfig.isOffline) {
        return await cageChangeOffline(data);
      }
      return await ApiService().postWithOfflineSupport(
        '/app/breeding/cageChange/',
        data: data,
        apiOption: ApiOption.noAlert(),
      );
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> cageChangeOffline(dynamic data) async {
    // 保存到本地数据库
    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();
    if (await BreedingDataService().batchInsertCageChange(list)) {
      return ResultModel.success('数据保存成功');
    } else {
      return ResultModel.fail('数据保存失败');
    }
  }

  Future<ResultModel> weight(dynamic data) async {
    try {
      if (AppConfig.isOffline) {
        return await weightOffline(data);
      }
      return await ApiService().postWithOfflineSupport(
        '/app/breeding/weight/',
        data: data,
        apiOption: ApiOption.noAlert(),
      );
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> weightOffline(dynamic data) async {
    // 保存到本地数据库
    Map<String, dynamic> weightData = {
      'rfid': data['rfid'],
      'weight': data['weight'],
      'date': data['date'],
      'is_export': 0,
    };
    if (await BreedingDataService().insertWeight(weightData)) {
      return ResultModel.success('数据保存成功');
    } else {
      return ResultModel.fail('数据保存失败');
    }
  }

  Future<ResultModel> cull(dynamic data) async {
    try {
      if (AppConfig.isOffline) {
        return await cullOffline(data);
      }
      return await ApiService().postWithOfflineSupport(
        '/app/breeding/cull/',
        data: data,
        apiOption: ApiOption.noAlert(),
      );
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> cullOffline(dynamic data) async {
    // 保存到本地数据库
    Map<String, dynamic> cullData = {
      'rfid': data['rfid'],
      'cull_reason': data['cullReason'],
      'disposal_method': data['disposalMethod'],
      'date': data['date'],
      'is_export': 0,
    };
    if (await BreedingDataService().insertCull(cullData)) {
      return ResultModel.success('数据保存成功');
    } else {
      return ResultModel.fail('数据保存失败');
    }
  }

  Future<ResultModel> batchCull(dynamic data) async {
    try {
      if (AppConfig.isOffline) {
        return await batchCullOffline(data);
      }
      return await ApiService().postWithOfflineSupport(
        '/app/breeding/batchCull/',
        data: data,
        apiOption: ApiOption.noAlert(),
      );
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> batchCullOffline(dynamic data) async {
    List<String> ids = data['rfids'];
    List<Map<String, dynamic>> batchCullData = ids.map<Map<String, dynamic>>((
      id,
    ) {
      return {
        'rfid': id,
        'cull_reason': data['cullReason'],
        'disposal_method': data['disposalMethod'],
        'date': data['date'],
        'is_export': 0,
      };
    }).toList();
    if (await BreedingDataService().batchInsertCull(batchCullData)) {
      return ResultModel.success('数据保存成功');
    } else {
      return ResultModel.fail('数据保存失败');
    }
  }
}