updateMetrics function

Future updateMetrics(dynamic type, dynamic metricNode)

Parsing metrics (positive, negative) from external plugin using Storage Listener key => global threat UUID unique (12) value => metric Map List metric Map List => {metric, normalization},....

Implementation

Future updateMetrics(var type,var metricNode) async {


  try {
    logger.d('indiA updateMetrics $metricNode');


    ///A Flag describes Positive or Negative
    ///To indicate if the higher is the sensor value is the better or not
    var flagNode = await metricNode.getValue('flag');
    //var nameNode = await metricNode.getValue('name');
    var flag = flagNode!.getValue('en');
    //var name = nameNode!.getValue('en');


//    if(CoreValues.scoreDescription == ''){
//          var goodOrbad = '';
//          flag == '1' ? goodOrbad = 'Good' : goodOrbad = 'Bad';
//          CoreValues.scoreDescription = "$goodOrbad,$name";
//    }
  //logger.d('indiC flagNode ${flagNode!.getValue('en')}');

  ///Normalization for metrics
  var normalizationValue = await forUpdateNormalization(metricNode);


  ///get threats related this metrics
  var threatsImpactNode = await metricNode.getValue('threatsImpact');
  var threatsMetricList = threatsImpactNode!.getValue('en')!.toString().trim().split(';');
  logger.d('indiC updateMetrics threatsMetricList $threatsMetricList');

  ///{threat UUID,metric;....}
  for (var metrics in threatsMetricList) {

        ///metricsList[0] => threat UUID
        ///metricsList[1] => high, medium, low
        var metricsList = metrics.split(',');

        ///value the higher is positive, lower is negative
        if (flag == '1') {
        //Node impactNormal = NodeImpl(':upipn', '');
        //await impactNormal.addOrUpdateValue(NodeValueImpl('impact', threatsImpact[1]));
        //await impactNormal.addOrUpdateValue(NodeValueImpl('normal', normalizationValue.toString()));

        var metricMap ={};
        metricMap['metric'] = metricsList[1];
        metricMap['normalization'] = normalizationValue.toString();
        //logger.d('indiC ${metricMap[1]} ${normalizationValue.toString()}');

        /// To get unique geiger threat name, search on All Global threat
        var threatName = CoreValues.threatUUIDGeigerName[metricsList[0]];
        /// To get unique geiger therat UUID, search on geiger unique Map
        var geigerthreatUUID = CoreValues.geigerThreatNameThreatUUID[threatName];


        if (type == Types.devices) {
            try {
                if(metricsList[0].isNotEmpty) CoreValues.devicePositive[geigerthreatUUID]!.add(metricMap);
                //print(CoreValues.devicePositive);
                //logger.d('indiC devicePositive 1 ${CoreValues.devicePositive}');
            } catch (e) {
                var temp = [];
                temp.add(metricMap);
                CoreValues.devicePositive[geigerthreatUUID] = temp;
                //print(CoreValues.devicePositive);
                //logger.d('indiC devicePositive 2 ${CoreValues.devicePositive}');
            }
        } else {
            try {
                if(metricsList[0].isNotEmpty)  CoreValues.userPositive[geigerthreatUUID]!.add(metricMap);
                //CoreValues.userPositive[threatsImpact[0]]!.add(impactNormal);
                //print(CoreValues.userPositive);
                //logger.d('indiC userPositive 1 ${CoreValues.userPositive}');
            } catch (e) {
                //logger.d('indiC uuu');
                var temp = [];
                temp.add(metricMap);
                //logger.d('indiC uuuu');
                CoreValues.userPositive[geigerthreatUUID] = temp;
                //logger.d('indiC userPositive 2 ${CoreValues.userPositive}');
                //print(CoreValues.userPositive);
            }
        }
        } else {


        var metricMap ={};
        metricMap['metric'] = metricsList[1];
        metricMap['normalization'] = normalizationValue.toString();

        var threatName = CoreValues.threatUUIDGeigerName[metricsList[0]]; // search on All Global threat
        var geigerthreatUUID = CoreValues.geigerThreatNameThreatUUID[threatName]; // search on profile threats
        //logger.d('indiC updateMetrics threatName ${threatName.toString()}');
        //logger.d('indiC updateMetrics GUUID ${GUUID.toString()}');


        if (type == Types.devices) {
            try {
              if(metricsList[0].isNotEmpty) CoreValues.deviceNegative[geigerthreatUUID]!.add(metricMap);
              //  CoreValues.deviceNegative[threatsImpact[0]]!.add(impactNormal);
              //print(CoreValues.deviceNegative);
            } catch (e) {
              var temp = [];
              temp.add(metricMap);
              CoreValues.deviceNegative[geigerthreatUUID] = temp;
              //print(CoreValues.deviceNegative);
            }
        } else {
        try {
              if(metricsList[0].isNotEmpty) CoreValues.userNegative[geigerthreatUUID]!.add(metricMap);
              //CoreValues.userNegative[threatsImpact[0]]!.add(impactNormal);
              //print(CoreValues.userNegative);
          } catch (e) {
              var temp = [];
              temp.add(metricMap);
              CoreValues.userNegative[geigerthreatUUID] = temp;
              //print(CoreValues.userNegative);
          }
        }
        }
  }

  }catch(e) {

  logger.d('indiA updateMetrics ${e.toString()}');

  }


}