Java Code Examples for org.apache.commons.collections4.MapUtils#isEmpty()

@Override
public boolean validate() throws ConfigException {
    if (CollectionUtils.isEmpty(retryDelays)) {
        throw new ConfigException("[CarreraConfiguration] retryDelays empty");
    } else if (thriftServer == null || !thriftServer.validate()) {
        throw new ConfigException("[CarreraConfiguration] thriftServer error");
    } else if (useKafka && (kafkaProducers <= 0 || MapUtils.isEmpty(kafkaConfigurationMap) || !kafkaConfigurationMap.values().stream().allMatch(KafkaConfiguration::validate))) {
        throw new ConfigException("[CarreraConfiguration] kafka config error");
    } else if (useRocketmq && (rocketmqProducers <= 0 || MapUtils.isEmpty(rocketmqConfigurationMap) || !rocketmqConfigurationMap.values().stream().allMatch(RocketmqConfiguration::validate))) {
        throw new ConfigException("[CarreraConfiguration] rocketmq config error");
    } else if (useAutoBatch && (autoBatch == null || !autoBatch.validate())) {
        throw new ConfigException("[CarreraConfiguration] autoBatch error");
    } else if (maxTps <= 0) {
        throw new ConfigException("[CarreraConfiguration] maxTps <= 0");
    } else if (tpsWarningRatio <= 0) {
        throw new ConfigException("[CarreraConfiguration] tpsWarningRatio <= 0");
    } else if (defaultTopicInfoConf == null) {
        throw new ConfigException("[CarreraConfiguration] defaultTopicInfoConf is null");
    }

    return true;
}
 

@ParameterizedTest
@MethodSource
public void testGetServiceInstanceEntity(Map<String, Object> serviceInstanceGetterResponse,
                                         Map<String, Object> userProvidedInstanceGetterResponse) {
    prepareServiceGetters(serviceInstanceGetterResponse, userProvidedInstanceGetterResponse);

    Map<String, Object> serviceInstanceEntity = serviceGetter.getServiceInstanceEntity(client, SERVICE_NAME, SPACE_ID);

    if (MapUtils.isEmpty(serviceInstanceGetterResponse)) {
        assertEquals(userProvidedInstanceGetterResponse, serviceInstanceEntity);
        verify(userProvidedInstanceGetter).getServiceInstanceEntity(client, SERVICE_NAME, SPACE_ID);
        return;
    }
    assertEquals(serviceInstanceGetterResponse, serviceInstanceEntity);
    verify(serviceInstanceGetter).getServiceInstanceEntity(client, SERVICE_NAME, SPACE_ID);
}
 

public Map<String, String> retrieveFromCluster(String traceId) throws Exception {
    JedisCluster cluster = RedisClusterFactory.getCluster();
    if (cluster == null) {
        throw new MonitorException("No redis cluster found, retrieve failed");
    }

    Map<String, String> monitorStatMap = cluster.hgetAll(traceId);
    if (MapUtils.isEmpty(monitorStatMap)) {
        return null;
    }

    return monitorStatMap;
}
 

/** Start all registered informers. */
public synchronized void startAllRegisteredInformers() {
  if (MapUtils.isEmpty(informers)) {
    return;
  }
  informers.forEach(
      (informerType, informer) ->
          startedInformers.computeIfAbsent(
              informerType, key -> informerExecutor.submit(informer::run)));
}
 

public List<MonitorStat> retrieve(String traceId, RedisType redisType) throws Exception {
    if (StringUtils.isEmpty(traceId)) {
        throw new MonitorException("Trace ID is null");
    }

    if (redisType == null) {
        throw new MonitorException("Redis type is null");
    }

    Map<String, String> monitorStatMap = null;
    switch (redisType) {
        case REDIS_SENTINEL:
            monitorStatMap = retrieveFromSentinel(traceId);
            break;
        case REDIS_CLUSTER:
            monitorStatMap = retrieveFromCluster(traceId);
            break;
    }

    if (MapUtils.isEmpty(monitorStatMap)) {
        return null;
    }

    List<MonitorStat> monitorStatList = retrieve(monitorStatMap);

    sort(monitorStatList);

    return monitorStatList;
}
 

@Override
public int calculateBestMailing(ComOptimization optimization) {

	Hashtable<Integer , CampaignStatEntry> stats = optimizationStatService.getStat(optimization);

	if(MapUtils.isEmpty(stats)) {
		return -1;
	}

	int[] mailingIDs = { optimization.getGroup2(),
			optimization.getGroup3(), optimization.getGroup4(),
			optimization.getGroup5() };
	
	int bestMailingID = optimization.getGroup1();
	double bestRate = calculateFactor(stats.get(optimization.getGroup1()), optimization.getEvalType());
			
	for(Integer mailingID : mailingIDs) {
				
		if( stats.containsKey(mailingID)) {
			if( bestRate < calculateFactor(stats.get(mailingID),optimization.getEvalType())) {
				bestMailingID = mailingID;
			}
		}
		
	}
			
	return bestMailingID;
}
 

private static Map<String, List<Long>> getConsumeModeStringMapper(Map<Long, List<Long>> mapper) {
    if (MapUtils.isEmpty(mapper)) {
        return null;
    }
    Map<String, List<Long>> stringMapper = Maps.newHashMap();
    for (Map.Entry<Long, List<Long>> entry : mapper.entrySet()) {
        stringMapper.put(String.valueOf(entry.getKey()), entry.getValue());
    }
    return stringMapper;
}
 

private void checkAndUpdateKafkaConfig(Map<String, KafkaConfiguration> oldConfig, Map<String, KafkaConfiguration> newConfig) {
    if (MapUtils.isEmpty(newConfig)) {
        LOGGER.info("rmq config is null or empty, illegal");
        return;
    }

    for (Map.Entry<String, KafkaConfiguration> config : newConfig.entrySet()) {
        if (oldConfig == null || !config.getValue().equals(oldConfig.get(config.getKey()))) {
            if (producerManager != null) {
                try {
                    producerManager.addAndUpdateRmqProducer(config.getKey(), ProducerType.KAFKA);
                    LogUtils.getMainLogger().info("kafka broker cluster update config success, cluster:{}", config.getKey());
                } catch (Exception ex) {
                    LogUtils.logError("ConfigManager.checkAndUpdateKafkaConfig", "broker cluster" + config.getKey() + "start failed", ex);
                }
            }
        }
    }

    Set<String> brokerClustersDel = new HashSet<>(oldConfig.keySet());
    brokerClustersDel.removeAll(newConfig.keySet());

    LogUtils.getMainLogger().info("kafka broker cluster delete:{}", brokerClustersDel);
    for (String brokerCluster : brokerClustersDel) {
        producerManager.deleteCluster(brokerCluster);
    }

    LogUtils.getMainLogger().info("kafka cluster update completely");
}
 

/**
 * @return joined by "&" sign URL params, or empty string if no params for this state
 */
public String getParamsString() {
    if (MapUtils.isEmpty(params)) {
        return "";
    }

    return params.entrySet()
            .stream()
            .map(entry -> String.format("%s=%s", entry.getKey(), URLEncodeUtils.encodeUtf8(entry.getValue())))
            .collect(Collectors.joining("&"));
}
 

/**
 * 通过code获取描述
 *
 * @param baseEnumType
 * @param code
 * @return
 */
public static EnumVo<? extends BaseEnum> getEnumVo(Class<? extends BaseEnum> baseEnumType, Integer code) {
    Map<Integer, EnumVo<? extends BaseEnum>> map = getMap(baseEnumType);
    if (MapUtils.isEmpty(map)) {
        return null;
    }
    return map.get(code);
}
 

public static AlertGroupFilter fromSpec(Map<String, String> spec) {
  if (MapUtils.isEmpty(spec)) {
    spec = Collections.emptyMap();
  }
  AlertGroupFilter alertGroupFilter = fromStringType(spec.get(GROUP_FILTER_TYPE_KEY));
  alertGroupFilter.setParameters(spec);

  return alertGroupFilter;
}
 

/**
 * 通过类型获取枚举desc集合
 *
 * @param baseEnumType
 * @return
 */
public static Collection<EnumVo<? extends BaseEnum>> getDescList(Class<? extends BaseEnum> baseEnumType) {
    Map<Integer, EnumVo<? extends BaseEnum>> map = getMap(baseEnumType);
    if (MapUtils.isEmpty(map)) {
        return null;
    }
    return map.values();
}
 

public static boolean isEdgePackage(String packageContent) {
    final Configuration pckgContent = fromJson(Json.parse(packageContent), Configuration.class);

    if (MapUtils.isNotEmpty(pckgContent.getContent().getModulesContent()) &&
            MapUtils.isEmpty(pckgContent.getContent().getDeviceContent())) {
        return true;
    }

    return false;
}
 

public ServiceOperation getLastServiceOperation(ProcessContext context, CloudServiceInstanceExtended service) {
    Map<String, Object> serviceInstanceEntity = getServiceInstanceEntity(context, service);

    if (MapUtils.isEmpty(serviceInstanceEntity)) {
        return getLastDeleteServiceOperation(context, service);
    }

    return getLastServiceOperation(serviceInstanceEntity);
}
 

public static boolean allowAutoDiscover(FeatureFlag featureFlag, CollectorType collectorType) {
	if(featureFlag == null) return false;
	String key = StringUtils.lowerCase(collectorType.toString());
	if(MapUtils.isEmpty(featureFlag.getFlags()) || Objects.isNull(featureFlag.getFlags().get(key))) return false;
	return BooleanUtils.toBoolean(featureFlag.getFlags().get(StringUtils.lowerCase(collectorType.toString())));
}
 

@Override
public boolean isMapEmpty(Map<?,?> map) {
	return MapUtils.isEmpty(map);
}
 

@SuppressWarnings("unchecked")
private void updateUserBadgeDataToES(Map<String, Object> map) {
  Future<Map<String, Object>> resultF =
      EsClientFactory.getInstance(JsonKey.REST)
          .getDataByIdentifier(
              ProjectUtil.EsType.user.getTypeName(), (String) map.get(JsonKey.USER_ID));
  Map<String, Object> result =
      (Map<String, Object>) ElasticSearchHelper.getResponseFromFuture(resultF);
  if (MapUtils.isEmpty(result)) {
    ProjectLogger.log(
        "UserBadgeAssertion:updateUserBadgeDataToES user with userId "
            + (String) map.get(JsonKey.USER_ID)
            + " not found",
        LoggerEnum.INFO.name());
    return;
  }
  if (CollectionUtils.isNotEmpty(
      (List<Map<String, Object>>) result.get(BadgingJsonKey.BADGE_ASSERTIONS))) {
    List<Map<String, Object>> badgeAssertionsList =
        (List<Map<String, Object>>) result.get(BadgingJsonKey.BADGE_ASSERTIONS);

    boolean bool = true;
    Iterator<Map<String, Object>> itr = badgeAssertionsList.iterator();
    while (itr.hasNext()) {
      Map<String, Object> tempMap = itr.next();
      if (((String) tempMap.get(JsonKey.ID)).equalsIgnoreCase((String) map.get(JsonKey.ID))) {
        itr.remove();
        bool = false;
      }
    }

    if (bool) {
      badgeAssertionsList.add(map);
    }
  } else {
    List<Map<String, Object>> mapList = new ArrayList<>();
    mapList.add(map);
    result.put(BadgingJsonKey.BADGE_ASSERTIONS, mapList);
  }
  updateDataToElastic(
      ProjectUtil.EsIndex.sunbird.getIndexName(),
      ProjectUtil.EsType.user.getTypeName(),
      (String) result.get(JsonKey.IDENTIFIER),
      result);
}
 

@Override
@Transactional
public boolean setActiveness(Map<Integer, Boolean> changeMap, @VelocityCheck int companyId, List<UserAction> userActions) {
    if (MapUtils.isEmpty(changeMap) || companyId <= 0) {
        return false;
    }

    Map<Integer, Boolean> activenessMap = emmActionDao.getActivenessMap(changeMap.keySet(), companyId);

    List<Integer> entriesToActivate = new ArrayList<>();
    List<Integer> entriesToDeactivate = new ArrayList<>();

    changeMap.forEach((actionId, active) -> {
        Boolean wasActive = activenessMap.get(actionId);

        // Ensure its exists and should be changed (wasActive != active).
        if (wasActive != null && !wasActive.equals(active)) {
            if (active) {
                entriesToActivate.add(actionId);
            } else {
                entriesToDeactivate.add(actionId);
            }
        }
    });

    if (entriesToActivate.size() > 0 || entriesToDeactivate.size() > 0) {
        String description = "";

        if (entriesToActivate.size() > 0) {
            emmActionDao.setActiveness(entriesToActivate, true, companyId);
            description += "Made active: " + StringUtils.join(entriesToActivate, ", ");

            if (entriesToDeactivate.size() > 0) {
                description += "\n";
            }
        }

        if (entriesToDeactivate.size() > 0) {
            emmActionDao.setActiveness(entriesToDeactivate, false, companyId);
            description += "Made inactive: " + StringUtils.join(entriesToDeactivate, ", ");
        }

        userActions.add(new UserAction("edit action activeness", description));

        return true;
    }

    return false;
}
 

public static boolean needInit() {
	return MapUtils.isEmpty(chainMap);
}
 

/**
 * 判断map是否为空
 *
 * @param map
 * @return
 */
public static boolean isEmpty(Map<?, ?> map) {
    return MapUtils.isEmpty(map);
}