Example usage for org.apache.commons.collections MapUtils getInteger

List of usage examples for org.apache.commons.collections MapUtils getInteger

Introduction

In this page you can find the example usage for org.apache.commons.collections MapUtils getInteger.

Prototype

public static Integer getInteger(Map map, Object key, Integer defaultValue) 

Source Link

Document

Looks up the given key in the given map, converting the result into an integer, using the default value if the the conversion fails.

Usage

From source file:net.me2day.async.processor.sample.DummyDistributor.java

@Override
public void initializeCompleted(Scope scope, Map<String, Object> configurationMap) {
    if (!ticket.equals(scope.getTarget())) {
        return;/* ww  w .  jav  a2  s  .  c  o m*/
    }

    int count = MapUtils.getInteger(configurationMap, "distributionCount", 2);
    if (count < 2) {
        count = 2;
    } else if (count > 50) {
        count = 50;
    }

    distributionCount = count;
    configurationMap.put("distributionCount", count);
}

From source file:com.jz.hcs.service.impl.SeckillServiceImpl.java

@Override
public SeckillExecution executeSeckillByProcedure(long seckillId, long userPhone, String md5) {
    if (md5 == null || !md5.equals(getMD5(seckillId))) {
        return new SeckillExecution(seckillId, StateEnum.DATA_REWITE);
    }//from w w w  .  j a  va  2 s.c  om

    Date killTime = new Date();
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("seckillId", seckillId);
    map.put("phone", userPhone);
    map.put("killTime", killTime);
    map.put("result", null);
    try {
        seckillDao.seckillByProcedure(map);
        int result = MapUtils.getInteger(map, "result", -2);
        if (result == 1) {
            SuccessKilled sk = successKilledDao.selectByIdWithSeckill(seckillId, userPhone);
            return new SeckillExecution(seckillId, StateEnum.SUCCESS, sk);
        } else {
            return new SeckillExecution(seckillId, StateEnum.stateOf(result));
        }
    } catch (Exception e) {
        LOG.error(e.getMessage(), e);
        return new SeckillExecution(seckillId, StateEnum.INNER_ERROR);
    }
}

From source file:com.ctrip.infosec.rule.executor.RulesExecutorService.java

/**
 * ?/*  www.j a  v  a  2 s  . c o m*/
 */
void buidFinalResult(RiskFact fact, boolean isAsync) {

    Map<String, Object> finalResult = Constants.defaultResult;
    Map<String, Object> finalResult4Async = Constants.defaultResult;
    if (!isAsync) {
        // finalResult
        for (Map<String, Object> rs : fact.results.values()) {
            finalResult = compareAndReturn(finalResult, rs);
        }
        fact.setFinalResult(Maps.newHashMap(finalResult));

        // originalRiskLevel
        int riskLevel = valueAsInt(finalResult, Constants.riskLevel);
        fact.finalResult.put(Constants.originalRiskLevel, riskLevel);

        fact.finalResult.remove(Constants.async);
        fact.finalResult.remove(Constants.timeUsage);
    } else {
        // finalResult4Async
        for (Map<String, Object> rs : fact.results4Async.values()) {
            finalResult4Async = compareAndReturn(finalResult4Async, rs);
        }
        fact.setFinalResult4Async(Maps.newHashMap(finalResult4Async));
        fact.finalResult4Async.remove(Constants.async);
        fact.finalResult4Async.remove(Constants.timeUsage);
    }

    // ?????
    if (!fact.finalWhitelistResult.isEmpty() && !isAsync) {
        // 0 : ???
        // 95?95???
        // 97??195????97
        int whitelistRiskLevel = valueAsInt(fact.finalWhitelistResult, Constants.riskLevel);
        if (whitelistRiskLevel == 0) {
            fact.setFinalResult(Maps.newHashMap(Constants.defaultResult));
        } else if (whitelistRiskLevel == 95) {
            fact.setFinalResult(Maps.newHashMap(fact.finalWhitelistResult));
        } else if (whitelistRiskLevel == 97) {
            int riskLevel = valueAsInt(finalResult, Constants.riskLevel);
            if (riskLevel < 195) {
                fact.setFinalResult(Maps.newHashMap(fact.finalWhitelistResult));
            }
        }
    }
    fact.finalResult.remove(Constants.async);
    fact.finalResult.remove(Constants.timeUsage);

    // finalResultGroupByScene
    Map<String, Map<String, Object>> finalResultGroupByScene = isAsync ? fact.finalResultGroupByScene4Async
            : fact.finalResultGroupByScene;
    Map<String, Map<String, Object>> resultsGroupByScene = isAsync ? fact.resultsGroupByScene4Async
            : fact.resultsGroupByScene;
    for (Map<String, Object> rs : resultsGroupByScene.values()) {
        List<String> sceneTypeList = valueAsList(rs, Constants.riskScene);
        if (sceneTypeList != null) {
            for (String sceneType : sceneTypeList) {
                int riskLevel = MapUtils.getInteger(rs, Constants.riskLevel, 0);
                String riskMessage = MapUtils.getString(rs, Constants.riskMessage, "");

                // finalResultGroupBySceneput 
                Map<String, Object> sceneResult = finalResultGroupByScene.get(sceneType);
                if (null == sceneResult) {
                    sceneResult = new HashMap<>();
                    sceneResult.put(Constants.riskLevel, riskLevel);
                    sceneResult.put(Constants.riskMessage, riskMessage);
                    finalResultGroupByScene.put(sceneType, sceneResult);
                } else {
                    int lastRiskLevel = MapUtils.getInteger(sceneResult, Constants.riskLevel, 0);
                    if (riskLevel > lastRiskLevel) {
                        sceneResult.put(Constants.riskLevel, riskLevel);
                        sceneResult.put(Constants.riskMessage, riskMessage);
                    }
                }
            }
        }
        Map<String, Map<String, Map<String, String>>> subLevelGroupBySceneType = valueAsMap(rs,
                Constants.subSceneType);
        if (subLevelGroupBySceneType != null) {
            for (String sceneType : subLevelGroupBySceneType.keySet()) {
                Map<String, Map<String, String>> subLevelGroupBySubSceneType = subLevelGroupBySceneType
                        .get(sceneType);

                //?
                Map<String, Object> sceneResult = finalResultGroupByScene.get(sceneType);
                if (null == sceneResult) {
                    sceneResult = new HashMap<>();
                    sceneResult.put(Constants.riskLevel, 0);
                    sceneResult.put(Constants.riskMessage, "PASS");
                    finalResultGroupByScene.put(sceneType, sceneResult);
                }

                int sceneRiskLevel = valueAsInt(sceneResult, Constants.riskLevel);
                Map<String, Map<String, String>> finalSubResults = Maps.newHashMap();

                for (Entry<String, Map<String, String>> entry : subLevelGroupBySubSceneType.entrySet()) {

                    // ????
                    int subSceneRiskLevel = valueAsInt(entry.getValue(), Constants.riskLevel);
                    if (subSceneRiskLevel > sceneRiskLevel) {
                        finalSubResults.put(entry.getKey(), entry.getValue());
                    }

                }

                sceneResult.put(Constants.subSceneType, finalSubResults);
            }
        }
    }
    if (!isAsync) {
        fact.setFinalResultGroupByScene(Maps.newHashMap(finalResultGroupByScene));
        fact.finalResultGroupByScene.remove(Constants.async);
        fact.finalResultGroupByScene.remove(Constants.timeUsage);
    } else {
        fact.setFinalResultGroupByScene4Async(Maps.newHashMap(finalResultGroupByScene));
        fact.finalResultGroupByScene4Async.remove(Constants.async);
        fact.finalResultGroupByScene4Async.remove(Constants.timeUsage);
    }
}

From source file:com.ctrip.infosec.rule.rabbitmq.RabbitMqMessageHandler.java

public void handleMessage(Object message) throws Exception {
    RiskFact fact = null;//from w  w  w  . j  a  v  a 2  s  .  co m
    String factTxt;
    InternalRiskFact internalRiskFact = null;
    try {

        if (message instanceof byte[]) {
            factTxt = new String((byte[]) message, Constants.defaultCharset);
        } else if (message instanceof String) {
            factTxt = (String) message;
        } else {
            throw new IllegalArgumentException("????\"String\"\"byte[]\"");
        }

        logger.info("MQ: fact=" + factTxt);
        fact = JSON.parseObject((String) factTxt, RiskFact.class);
        Contexts.setAsync(true);
        Contexts.setLogPrefix("[" + fact.eventPoint + "][" + fact.eventId + "] ");
        SarsMonitorContext.setLogPrefix(Contexts.getLogPrefix());

        boolean traceLoggerEnabled = MapUtils.getBoolean(fact.ext, Constants.key_traceLogger, true);
        TraceLogger.enabled(traceLoggerEnabled);

        RuleMonitorHelper.newTrans(fact, RuleMonitorType.CP_ASYNC);

        // ??
        // S0 - ??
        // S1 - ?
        // S2 - ??
        // S3 - 
        // ??GET
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.GET);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[??]");
            eventDataMergeService.executeRedisGet(fact);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }
        // ?            
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.PRE_RULE_WRAP);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[?]");
            preRulesExecutorService.executePreRules(fact, true);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }
        // 
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.RULE_WRAP);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[]");
            rulesExecutorService.executeAsyncRules(fact);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }
        // 
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.MODEL_RULE_WRAP);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[]");
            modelRulesExecutorService.executeModelRules(fact);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }
        // ??
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.POST_RULE_WRAP);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[??]");
            postRulesExecutorService.executePostRules(fact, true);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }
        // ??PUT
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.PUT);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[??]");
            eventDataMergeService.executeRedisPut(fact);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }
        //Counter??
        try {
            RuleMonitorHelper.newTrans(fact, RuleMonitorType.PUSH_WRAP);
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[Counter?]");
            counterPushRuleExrcutorService.executeCounterPushRules(fact, true);
        } finally {
            TraceLogger.commitTrans();
            RuleMonitorHelper.commitTrans(fact);
        }

        RuleMonitorHelper.commitTrans(fact);

        // -------------------------------- ? -------------------------------------- //
        beforeInvoke("CardRiskDB.CheckResultLog.saveRuleResult");
        Long riskReqId = MapUtils.getLong(fact.ext, Constants.key_reqId);
        boolean outerReqId = riskReqId != null;
        internalRiskFact = offline4jService.saveForOffline(fact);
        if (internalRiskFact != null && internalRiskFact.getReqId() > 0) {
            riskReqId = internalRiskFact.getReqId();
        }

        // ?
        beforeInvoke("CardRiskDB.CheckResultLog.saveRuleResult");
        try {
            TraceLogger.beginTrans(fact.eventId, "S3");
            TraceLogger.setLogPrefix("[?CheckResultLog]");
            if (riskReqId != null && riskReqId > 0) {
                TraceLogger.traceLog("reqId = " + riskReqId);
                saveRuleResult(riskReqId, fact, fact.whitelistResults, outerReqId);
                saveRuleResult(riskReqId, fact, fact.results, outerReqId);
                saveRuleResult(riskReqId, fact, fact.results4Async, outerReqId);
                saveRuleResult(riskReqId, fact, fact.resultsGroupByScene, outerReqId);
                saveRuleResult(riskReqId, fact, fact.resultsGroupByScene4Async, outerReqId);
            }
        } catch (Exception ex) {
            fault("CardRiskDB.CheckResultLog.saveRuleResult");
            logger.error(
                    Contexts.getLogPrefix()
                            + "?[InfoSecurity_CheckResultLog]?.",
                    ex);
        } finally {
            long usage = afterInvoke("CardRiskDB.CheckResultLog.saveRuleResult");
            TraceLogger.traceLog(": " + usage + "ms");
            TraceLogger.commitTrans();
        }

    } catch (Throwable ex) {
        logger.error(Contexts.getLogPrefix() + "invoke handleMessage exception.", ex);
    } finally {
        if (fact != null) {
            // ??DataDispatcher
            try {
                beforeInvoke("DataDispatcher.sendMessage");
                dispatcherMessageSender.sendToDataDispatcher(fact);
            } catch (Exception ex) {
                fault("DataDispatcher.sendMessage");
                logger.error(Contexts.getLogPrefix() + "send dispatcher message fault.", ex);
            } finally {
                afterInvoke("DataDispatcher.sendMessage");
            }

            int riskLevel = MapUtils.getInteger(fact.finalResult, Constants.riskLevel, 0);
            if (riskLevel > 0) {
                // ??Offline4J
                if (internalRiskFact != null
                        && MapUtils.getBoolean(fact.ext, Offline4jService.PUSH_OFFLINE_WORK_ORDER_KEY, false)) {
                    beforeInvoke("Offline.sendMessage");
                    try {
                        Object eventObj = riskEventConvertor.convert(internalRiskFact, riskLevel,
                                HeaderMappingBizType.Offline4J);
                        offlineMessageSender.sendToOffline(eventObj);
                    } catch (Exception ex) {
                        fault("Offline.sendMessage");
                        logger.error(Contexts.getLogPrefix() + "send Offline4J message fault.", ex);
                    } finally {
                        afterInvoke("Offline.sendMessage");
                    }
                }
            }

            try {

                //??factresults0?
                boolean withScene = Constants.eventPointsWithScene.contains(fact.eventPoint);
                if (!withScene) {
                    //?
                    for (Entry<String, Map<String, Object>> entry : fact.results.entrySet()) {
                        String ruleNo = entry.getKey();
                        int rLevel = NumberUtils
                                .toInt(MapUtils.getString(entry.getValue(), Constants.riskLevel));
                        if (rLevel > 0) {
                            //??
                            String distinct = getDistinctValue(fact, ruleNo);
                            RuleMonitorRepository.increaseCounter(fact.getEventPoint(), ruleNo, distinct);
                        }
                    }
                    for (Entry<String, Map<String, Object>> entry : fact.results4Async.entrySet()) {
                        String ruleNo = entry.getKey();
                        int rLevel = NumberUtils
                                .toInt(MapUtils.getString(entry.getValue(), Constants.riskLevel));
                        if (rLevel > 0) {
                            //??
                            String distinct = getDistinctValue(fact, ruleNo);
                            RuleMonitorRepository.increaseCounter(fact.getEventPoint(), ruleNo, distinct);
                        }
                    }
                } else {
                    //
                    for (Entry<String, Map<String, Object>> entry : fact.resultsGroupByScene.entrySet()) {
                        String ruleNo = entry.getKey();
                        int rLevel = NumberUtils
                                .toInt(MapUtils.getString(entry.getValue(), Constants.riskLevel));
                        if (rLevel > 0) {
                            //                                RuleMonitorRepository.increaseCounter(fact.getEventPoint(), ruleNo);
                            //??
                            String distinct = getDistinctValue(fact, ruleNo);
                            RuleMonitorRepository.increaseCounter(fact.getEventPoint(), ruleNo, distinct);
                        }
                    }
                    for (Entry<String, Map<String, Object>> entry : fact.resultsGroupByScene4Async.entrySet()) {
                        String ruleNo = entry.getKey();
                        int rLevel = NumberUtils
                                .toInt(MapUtils.getString(entry.getValue(), Constants.riskLevel));
                        if (rLevel > 0) {
                            //                                RuleMonitorRepository.increaseCounter(fact.getEventPoint(), ruleNo);
                            //??
                            String distinct = getDistinctValue(fact, ruleNo);
                            RuleMonitorRepository.increaseCounter(fact.getEventPoint(), ruleNo, distinct);
                        }
                    }
                }

            } catch (Exception ex) {
                logger.error(Contexts.getLogPrefix() + "RuleMonitorRepository increaseCounter fault.", ex);
            }

        }
    }
}

From source file:com.ctrip.infosec.rule.rabbitmq.RabbitMqMessageHandler.java

private Map<String, PersistColumnProperties> prepareRiskControlCheckResultLog(Long riskReqId, String ruleType,
        Entry<String, Map<String, Object>> entry, Long riskLevel, String eventPoint, Long orderId,
        Integer orderType, Integer subOrderType) {
    Map<String, PersistColumnProperties> map = Maps.newHashMap();
    PersistColumnProperties props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DB_PK);
    props.setColumnType(DataUnitColumnType.Long);
    map.put("LogID", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Long);
    props.setValue(riskReqId);//  w ww .j  a  va 2 s. co m
    map.put("RID", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    props.setValue(ruleType);
    map.put("RuleType", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Int);
    props.setValue(MapUtils.getInteger(entry.getValue(), Constants.ruleId, 0));
    map.put("RuleID", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    if ("B".equals(valueAsString(entry.getValue(), Constants.ruleType))) {
        props.setValue(valueAsString(entry.getValue(), Constants.ruleName));
    } else {
        props.setValue(entry.getKey());
    }
    map.put("RuleName", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Long);
    props.setValue(riskLevel);
    map.put("RiskLevel", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    props.setValue(MapUtils.getString(entry.getValue(), Constants.riskMessage));
    map.put("RuleRemark", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.CUSTOMIZE);
    props.setColumnType(DataUnitColumnType.Data);
    props.setExpression("const:now:date");
    map.put("DataChange_LastTime", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    props.setValue(eventPoint);
    map.put("EventPoint", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Long);
    props.setValue(orderId);
    map.put("OrderId", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Int);
    props.setValue(orderType);
    map.put("OrderType", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Int);
    props.setValue(subOrderType);
    map.put("SubOrderType", props);
    return map;
}

From source file:com.ctrip.infosec.rule.rabbitmq.RabbitMqMessageHandler.java

private Map<String, PersistColumnProperties> prepareInfoSecurityCheckResultLog(Long riskReqId, String ruleType,
        Entry<String, Map<String, Object>> entry, Long riskLevel) {
    Map<String, PersistColumnProperties> map = Maps.newHashMap();
    PersistColumnProperties props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DB_PK);
    props.setColumnType(DataUnitColumnType.Long);
    map.put("LogID", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Long);
    props.setValue(riskReqId);/* ww w  .  j  a v  a 2  s  . co m*/
    map.put("ReqID", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    props.setValue(ruleType);
    map.put("RuleType", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Int);
    props.setValue(MapUtils.getInteger(entry.getValue(), Constants.ruleId, 0));
    map.put("RuleID", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    if ("B".equals(valueAsString(entry.getValue(), Constants.ruleType))) {
        props.setValue(valueAsString(entry.getValue(), Constants.ruleName));
    } else {
        props.setValue(entry.getKey());
    }
    map.put("RuleName", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Long);
    props.setValue(riskLevel);
    map.put("RiskLevel", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.String);
    props.setValue(MapUtils.getString(entry.getValue(), Constants.riskMessage));
    map.put("RuleRemark", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.CUSTOMIZE);
    props.setColumnType(DataUnitColumnType.Data);
    props.setExpression("const:now:date");
    map.put("CreateDate", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.CUSTOMIZE);
    props.setColumnType(DataUnitColumnType.Data);
    props.setExpression("const:now:date");
    map.put("DataChange_LastTime", props);

    props = new PersistColumnProperties();
    props.setPersistColumnSourceType(PersistColumnSourceType.DATA_UNIT);
    props.setColumnType(DataUnitColumnType.Int);
    props.setValue(0);
    map.put("IsHighlight", props);

    return map;
}

From source file:com.ctrip.infosec.rule.util.Emitter.java

/**
 * finalResult/*ww w  . j  a  va  2  s  .c  o  m*/
 */
static Map<String, Object> compareAndReturn(Map<String, Object> oldResult, Map<String, Object> newResult) {
    if (newResult == null) {
        return oldResult;
    }
    if (oldResult == null) {
        return newResult;
    }
    int newRriskLevel = MapUtils.getInteger(newResult, Constants.riskLevel, 0);
    int oldRriskLevel = MapUtils.getInteger(oldResult, Constants.riskLevel, 0);
    if (newRriskLevel > oldRriskLevel) {
        return newResult;
    }
    return oldResult;
}

From source file:com.ctrip.infosec.rule.executor.RulesExecutorService.java

/**
 * finalResult//from  w  ww  .java  2s  .c om
 */
Map<String, Object> compareAndReturn(Map<String, Object> oldResult, Map<String, Object> newResult) {
    if (newResult == null) {
        return oldResult;
    }
    if (oldResult == null) {
        return newResult;
    }
    int newRriskLevel = MapUtils.getInteger(newResult, Constants.riskLevel, 0);
    int oldRriskLevel = MapUtils.getInteger(oldResult, Constants.riskLevel, 0);
    if (newRriskLevel > oldRriskLevel) {
        return newResult;
    }
    return oldResult;
}

From source file:org.isatools.isatab.isaconfigurator.validators.ProtocolFieldsValidator.java

private boolean validateProtocolFields(Record record, Field inField, Field outField, List<Field> protoAppFields,
        List<ProtocolFieldType> cfgProtos) {
    boolean result = true;

    MappingUtils mappingUtils = new MappingUtils(store);
    Study study = mappingUtils.getStudyFromSection(record.getParent());
    String studyAcc = study.getAcc();

    Map<ProtocolFieldType, Integer> matchedCfProtos = new HashMap<ProtocolFieldType, Integer>();

    for (Field papp : protoAppFields) {
        String pappVal = StringUtils.trimToNull(record.getString(papp.getIndex()));
        if (pappVal != null) {
            // check this proto app is in the config
            ////from   w w w .  j a  va  2s. c om

            boolean isMatched = false;

            Protocol proto = store.getType(Protocol.class, studyAcc + "\\" + pappVal);
            if (proto == null) {
                throw new TabMissingValueException(i18n.msg("ref_protocol_missing", pappVal, study.getAcc()));
            }

            ProtocolType ptype = proto.getType();
            String ptypeStr = ptype == null ? null : StringUtils.trimToNull(ptype.getName());
            if (ptypeStr != null) {
                for (ProtocolFieldType cfproto : cfgProtos) {
                    String cfPtype = StringUtils.trimToNull(cfproto.getProtocolType());
                    if (cfPtype == null) {
                        continue;
                    }

                    if (StringUtils.equalsIgnoreCase(cfPtype, ptypeStr)) {
                        isMatched = true;
                        matchedCfProtos.put(cfproto, MapUtils.getInteger(matchedCfProtos, cfproto, 0) + 1);
                        // TODO: Do specific checkings
                    }
                }
            }

            if (!isMatched && ptypeStr != null) {
                messages.add("The used protocol type '" + ptypeStr
                        + "' is not defined in the ISA-configuration as a protocol between '"
                        + inField.getAttr("header") + "' and '" + outField.getAttr("header")
                        + "', in the file '" + record.getParent().getFileId() + "'");
                result = false;
            }
        }

        // Now check about the cfg protocol that are possibly not matched or matched too many times
        for (ProtocolFieldType cfproto : cfgProtos) {
            String cfPtype = StringUtils.trimToNull(cfproto.getProtocolType());
            if (cfPtype == null) {
                continue;
            }

            int nmatches = MapUtils.getInteger(matchedCfProtos, cfgProtos, 0);
            if (nmatches == 0) {
                if (cfproto.getIsRequired()) {
                    messages.add("The protocol type '" + cfPtype + "' is required between '"
                            + inField.getAttr("header") + "' and '" + outField.getAttr("header")
                            + "', in the file '" + record.getParent().getFileId() + "'");
                    result = false;
                }
            } else if (nmatches > 1) {
                messages.add("Strangely, the protocol '" + pappVal + "' is used more than once between '"
                        + inField.getAttr("header") + "' and '" + outField.getAttr("header")
                        + "', in the file '" + record.getParent().getFileId() + "'");
                result = false;
            }
        }
    }

    return result;
}

From source file:org.whitesource.agent.report.PolicyCheckReport.java

private Collection<LicenseHistogramDataPoint> createLicenseHistogram(BaseCheckPoliciesResult result) {
    Collection<LicenseHistogramDataPoint> dataPoints = new ArrayList<LicenseHistogramDataPoint>();

    // create distribution histogram
    Map<String, Integer> licenseHistogram = new HashMap<String, Integer>();
    for (Map.Entry<String, Collection<ResourceInfo>> entry : result.getProjectNewResources().entrySet()) {
        for (ResourceInfo resource : entry.getValue()) {
            for (String license : resource.getLicenses()) {
                licenseHistogram.put(license, MapUtils.getInteger(licenseHistogram, license, 0) + 1);
            }//from   w  ww  .  ja va  2 s  .com
        }
    }

    // sort by count descending
    List<Map.Entry<String, Integer>> licenses = new ArrayList<Map.Entry<String, Integer>>(
            licenseHistogram.entrySet());
    Collections.sort(licenses, new ValueComparator());

    // create data points
    if (!licenses.isEmpty()) {
        // first licenses
        for (Map.Entry<String, Integer> entry : licenses.subList(0, Math.min(LICENSE_LIMIT, licenses.size()))) {
            dataPoints.add(new LicenseHistogramDataPoint(entry.getKey(), entry.getValue()));
        }

        // aggregation of histogram tail
        int tailSize = licenses.size() - LICENSE_LIMIT;
        int tailSum = 0;
        if (tailSize > 0) {
            for (Map.Entry<String, Integer> entry : licenses.subList(LICENSE_LIMIT, licenses.size())) {
                tailSum += entry.getValue();
            }
            dataPoints.add(new LicenseHistogramDataPoint(OTHER_LICENSE + " (" + tailSize + ")", tailSum));
        }

        // normalize bar height
        float factor = MAX_BAR_HEIGHT / (float) Math.max(tailSum, licenses.get(0).getValue());
        for (LicenseHistogramDataPoint dataPoint : dataPoints) {
            dataPoint.setHeight((int) (factor * dataPoint.getOccurrences()));
        }
    }

    return dataPoints;
}