crtThreatScore function

Implementation

Future crtThreatScore(var type) async {
  var positiveMetrics = 0.0;
  var negativeMetrics = 0.0;
  var implementedRecommendations = 0.0;
  var gspt = 0.0;
  var treatsScores = '';

  logger.d('devicePositive => ${CoreValues.devicePositive}');
  logger.d('deviceNegative => ${CoreValues.deviceNegative}');
  logger.d('deviceImplementedRecommendation => ${CoreValues.deviceImplementedRecommendation}');

  logger.d('userPositive => ${CoreValues.userPositive}');
  logger.d('userNegative => ${CoreValues.userNegative}');
  logger.d('userImplementedRecommendation => ${CoreValues.userImplementedRecommendation}');

  try {

    ///loop based on unique geiger threat uuid (12)
    for (String threatUUID in CoreValues.geigerThreatUUID) {

      positiveMetrics = 0.0;
      negativeMetrics = 0.0;
      implementedRecommendations = 0.0;
      gspt = 0.0;

      logger.d('indiC deviceImplementedRecommendation ${CoreValues.deviceImplementedRecommendation}');
      logger.d('indiC userImplementedRecommendation ${CoreValues.userImplementedRecommendation}');

      if (type == Types.devices) {
        //logger.i('indiC Types.devices');

        ///calculate positive metrics to risk score
        if (CoreValues.devicePositive.isNotEmpty && CoreValues.devicePositive.containsKey(threatUUID)) {
          logger.i('Types.devicePositive');
          positiveMetrics = await pnMetrics(CoreValues.devicePositive, threatUUID);
        }
        ///calculate negative metrics to risk score
        if (CoreValues.deviceNegative.isNotEmpty && CoreValues.deviceNegative.containsKey(threatUUID)) {
          logger.i('Types.deviceNegative');
          negativeMetrics = await pnMetrics(CoreValues.deviceNegative, threatUUID);
        }
        ///calculate implemented recommendations
        if (CoreValues.deviceImplementedRecommendation.isNotEmpty && CoreValues.deviceImplementedRecommendation.containsKey(threatUUID)) {
          logger.i('Types.deviceRECO');
          implementedRecommendations = await recoMetrics(CoreValues.deviceImplementedRecommendation, threatUUID);
        }
      } else if (type == Types.users) {
        //logger.i('indiC Types.users');
        //positiveMetrics = await pnMetrics(CoreValues.userPositive, threatUUID);
        //negativeMetrics = await pnMetrics(CoreValues.userNegative, threatUUID);
        ///calculate positive metrics to risk score
        if (CoreValues.userPositive.isNotEmpty && CoreValues.userPositive.containsKey(threatUUID)) {
          logger.i('Types.userPositive');
          positiveMetrics = await pnMetrics(CoreValues.userPositive, threatUUID );
        }
        ///calculate negative metrics to risk score
        if (CoreValues.userNegative.isNotEmpty && CoreValues.userNegative.containsKey(threatUUID)) {
          logger.i('Types.userNegative');
          negativeMetrics = await pnMetrics(CoreValues.userNegative, threatUUID);
        }
        ///calculate implemented recommendations
        if (CoreValues.userImplementedRecommendation.isNotEmpty && CoreValues.userImplementedRecommendation.containsKey(threatUUID)){
          logger.i('Types.userRECO');
          implementedRecommendations = await recoMetrics(CoreValues.userImplementedRecommendation, threatUUID);
        }
      }
      logger.d('<=========indiA crtThreatScore $implementedRecommendations, $positiveMetrics, $negativeMetrics  ==============================>');
      ///based on geiger indicator algorithm (threats based risk score calculation approach)
      gspt = 50 + (50 * negativeMetrics) - (25 * (positiveMetrics + implementedRecommendations));

      logger.d('indiC gspt $gspt');


      treatsScores += '$threatUUID,$gspt;';

      logger.d('indiC treatsScores $treatsScores');

      type == Types.devices
          ? CoreValues.deviceThreatScore[threatUUID] = gspt
          : CoreValues.userThreatScore[threatUUID] = gspt;


      logger.d('indiC deviceThreatScore ${CoreValues.deviceThreatScore[threatUUID] = gspt}');
      logger.d('indiC userThreatScore  ${CoreValues.userThreatScore[threatUUID] = gspt}');
    }


  }catch(e){
    logger.e(e);
  }



  return treatsScores;
}