fis_lib_measure/lib/view/measure/measure_view_controller.dart

import 'package:fis_common/logger/logger.dart';
import 'package:fis_jsonrpc/rpc.dart';
import 'package:fis_measure/interfaces/process/items/item_metas.dart';
import 'package:fis_measure/interfaces/process/items/terms.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/items/item_meta_convert.dart';
import 'package:fis_measure/process/workspace/measure_3d_view_controller.dart';
import 'package:fis_measure/process/workspace/measure_data_controller.dart';
import 'package:fis_measure/process/workspace/measure_handler.dart';
import 'package:fis_measure/view/measure/measure_config/measure_configuation_page.dart';
import 'package:get/get.dart';

class MeasureMetaController extends GetxController {
  /// 数据
  late final measureData = Get.find<MeasureDataController>();
  late final measureHandler = Get.find<MeasureHandler>();
  late final measure3DViewController = Get.find<Measure3DViewController>();
  get isCarotid2D =>
      measure3DViewController.curMeasureMode == MeasureMode.carotid2DMode;

  /// 跟超声机端保持一致，配置 项目写死
  List<ItemMetaGroup> getMeasureConfigurationGroupName() {
    return [
      ItemMetaGroup('Common', [], true),
      ItemMetaGroup('ABD', [], false),
      ItemMetaGroup('CARD', [], false),
      ItemMetaGroup('GYN', [], false),
      ItemMetaGroup('OB', [], false),
      ItemMetaGroup('VAS', [], false),
    ];
  }

  /// 获取组合测量项
  void updateItemList() {
    if (isCarotid2D) return; //颈动脉2D采用写死的测量项，无需更新

    /// 格式化数据
    List<ItemMeta> itemMetaList = [];
    for (var element in measureData.itemMetaList) {
      if (measureData.getMeasureApplicationList.contains(element.description)) {
        itemMetaList.add(element);
      }
    }
    measureData.curItemMetaList = itemMetaList;
  }

  void setAvailableModes(String name) {
    List<MeasureModeDTO> models = measureData.availableModes;
    measureData.currentMode = name;
    if (models.isNotEmpty) {
      ///群组列表
      var groups = models
          .firstWhereOrNull(
              (element) => element.modeName == measureData.currentMode)
          ?.availableGroups;

      if (groups != null && groups.isNotEmpty) {
        ///项目列表
        var folders = groups[0].availableFolders;
        if (folders != null && folders.isNotEmpty) {
          measureData.getMeasureApplicationList =
              folders[0].workingItemNames ?? [];
          if (folders[0].availableItems != null) {
            measureData.itemMetaList = folders[0]
                .availableItems!
                // 排除不支持的测量项
                .where((element) =>
                    !MeasureUnsupportedTerms.items.contains(element.name))
                .map((element) {
                  try {
                    return ItemMetaConverter(element).output();
                  } catch (e) {
                    logger.e(
                      "Item meta -[${element.name}] convert error; JSON-Text: ${element.toJson()}",
                      e,
                    );
                    return null;
                  }
                })
                .where((element) => element != null)
                .map((e) => e!)
                .toList();
            updateItemList();
          }
          if (measureData.getMeasureApplicationList.isNotEmpty) {
            measureData.curItemMetaListChanged.emit(this, []);
          }
        }
      }
    }
  }

  List<ItemMetaDTO> setMeasureConfigItemMetaList() {
    List<ItemMetaDTO> _measureConfigItemMetaList = [];
    var groups = measureData.availableModes
        .firstWhereOrNull(
            (element) => element.modeName == measureData.currentMode)
        ?.availableGroups;
    (groups![0].availableFolders![0].availableItems)?.toList().forEach(
      (e) {
        if (!MeasureUnsupportedTerms.items.contains(e.name)) {
          _measureConfigItemMetaList.add(e);
        }
      },
    );

    return _measureConfigItemMetaList;
  }

  /// 测量项配置组
  void measureConfig() {
    List<ItemMetaGroup> _itemMetaConfigurationList = [];
    Map<String, List<ItemMetaDTO>> _group = {};
    getMeasureConfigurationGroupName().forEach(
      ((element) {
        List<ItemMetaDTO> itemMetaListGroupItem = [];
        var groups = measureData.availableModes
            .firstWhereOrNull(
                (element) => element.modeName == measureData.currentMode)
            ?.availableGroups;
        (groups![0].availableFolders![0].availableItems)?.toList().forEach(
          (e) {
            if (e.categories!.toList().contains(element.itemMetaGroupTitle)) {
              if (!MeasureUnsupportedTerms.items.contains(e.name)) {
                itemMetaListGroupItem.add(e);
              }
            }
            _group[element.itemMetaGroupTitle] = itemMetaListGroupItem;
          },
        );
      }),
    );
    _group.forEach(
      (key, value) {
        if (key == 'Common') {
          _itemMetaConfigurationList.add(
            ItemMetaGroup(key, value, true),
          );
        } else {
          _itemMetaConfigurationList.add(
            ItemMetaGroup(key, value, false),
          );
        }
      },
    );
    measureData.itemMetaListGroup = _itemMetaConfigurationList;
  }

  void changeItem(ItemMeta itemMeta) {
    final application = Get.find<IApplication>();
    application.switchItem(itemMeta);
  }
}