{@link Specification} for retrieving {@link Target}s that have no Action
of the {@link RolloutGroup}.

@param group
the {@link RolloutGroup}
@return the {@link Target} {@link Specification}
483595
public static Specification<JpaTarget> hasNoActionInRolloutGroup(final Long group) {
        return (targetRoot, query, cb) -> {
            final ListJoin<JpaTarget, RolloutTargetGroup> rolloutTargetJoin = targetRoot
                    .join(JpaTarget_.rolloutTargetGroup, JoinType.INNER);
            rolloutTargetJoin.on(
                    cb.equal(rolloutTargetJoin.get(RolloutTargetGroup_.rolloutGroup).get(JpaRolloutGroup_.id), group));

            final ListJoin<JpaTarget, JpaAction> actionsJoin = targetRoot.join(JpaTarget_.actions, JoinType.LEFT);
            actionsJoin.on(cb.equal(actionsJoin.get(JpaAction_.rolloutGroup).get(JpaRolloutGroup_.id), group));

            return cb.isNull(actionsJoin.get(JpaAction_.id));
        };
    }
1220159
public com.google.api.ads.adwords.axis.v201809.cm.AdGroupCriterion getAdGroupCriterion() {
        return adGroupCriterion;
    }
959882
public String group(String groupName) {
        int idx = groupIndex(groupName);
        if (idx < 0) {
          throw new IndexOutOfBoundsException("No group \"" + groupName + "\"");
        }
        return group(idx);
    }
693069
public String get(String group, String key) {
		return this.groupedMap.get(group, key);
	}
341582
public static <GROUP extends Serializable> ExecutorConfig<GROUP> basicGroupable() {
        return new ExecutorConfig<GROUP>()
                    .withTaskIdAdapter((TaskIdAdapter<Groupable<GROUP>, GROUP, ?>) new DefaultGroupableTaskIdAdapter<GROUP>());
    }
262998
@JsonIgnore
    public Map<String, Set<String>> getGroupingSpecification() {
        Map<String, Set<String>> result = new LinkedHashMap<>();
        if (!StringUtils.isBlank(grouping)) {
            String[] groups = split(grouping, '|');
            for (String group : groups) {
                String[] groupSpec = split(group.trim(), '=');
                if (groupSpec.length != 2) throw new ExportRequestGroupingFormatException(grouping);
                String groupName = groupSpec[0].trim();
                result.put(
                        groupName,
                        Sets.newLinkedHashSet(
                                Arrays.asList(
                                        split(groupSpec[1].trim(), ',')
                                ).stream()
                                        .map(String::trim)
                                        .collect(Collectors.toList())
                        )
                );
            }
        }
        return result;
    }
5153
public static RolloutGroup verifyRolloutGroupHasConditions(final RolloutGroup group) {
        if (group.getTargetPercentage() < 1F || group.getTargetPercentage() > 100F) {
            throw new ValidationException("Target percentage has to be between 1 and 100");
        }

        if (group.getSuccessCondition() == null) {
            throw new ValidationException("Rollout group is missing success condition");
        }
        if (group.getSuccessAction() == null) {
            throw new ValidationException("Rollout group is missing success action");
        }
        return group;
    }
1180579
public static List<String> replaceNullValueWithEmptyGroup(@Nonnull final List<String> groups) {
		Check.notNull(groups, "groups");

		final List<String> result = new ArrayList<String>(groups.size());
		for (final String group : groups) {
			if (group == null) {
				result.add(EMPTY_GROUP);
			} else {
				result.add(group);
			}
		}
		for (int i = result.size(); i < MIN_GROUP_SIZE; i++) {
			result.add(EMPTY_GROUP);
		}
		return result;
	}
321810
@GET
    @Path("{group}")
    public Iterator<EmoRole> getAllRolesInGroup(@PathParam("group") String group,
                                                final @Authenticated Subject subject) {
        return _uac.getAllRolesInGroup(subject, group);
    }
181821
public PropertyConstraint inGroup(String propertyName, Object[] group) {
        return value(propertyName, new InGroup(group));
    }
926912
public Set<Entry<String, String>> entrySet(String group) {
		return this.groupedMap.entrySet(group);
	}
1192930
public Setting getSetting(String group) {
		final Setting setting = new Setting();
		setting.putAll(this.getMap(group));
		return setting;
	}
50913
@Bean
    @ConditionalOnMissingBean
    TargetManagement targetManagement(final EntityManager entityManager, final QuotaManagement quotaManagement,
            final TargetRepository targetRepository, final TargetMetadataRepository targetMetadataRepository,
            final RolloutGroupRepository rolloutGroupRepository,
            final DistributionSetRepository distributionSetRepository,
            final TargetFilterQueryRepository targetFilterQueryRepository,
            final TargetTagRepository targetTagRepository, final NoCountPagingRepository criteriaNoCountDao,
            final ApplicationEventPublisher eventPublisher, final BusProperties bus, final TenantAware tenantAware,
            final AfterTransactionCommitExecutor afterCommit, final VirtualPropertyReplacer virtualPropertyReplacer,
            final JpaProperties properties) {
        return new JpaTargetManagement(entityManager, quotaManagement, targetRepository, targetMetadataRepository,
                rolloutGroupRepository, distributionSetRepository, targetFilterQueryRepository, targetTagRepository,
                criteriaNoCountDao, eventPublisher, bus, tenantAware, afterCommit, virtualPropertyReplacer,
                properties.getDatabase());
    }
298149
@Override
    public Iterator findMemberGroups(IEntityGroup group) throws GroupsException {

        if (isTreeRefreshRequired()) {
            refreshTree();
        }

        log.debug("Invoking findMemberGroups() for group:  {}", group.getLocalKey());

        List<IEntityGroup> rslt = new ArrayList<>();

        List<String> list = groupsTree.getChildren().get(group.getLocalKey());
        if (list != null) {
            // should only reach this code if its a SmartLdap managed group...
            for (String s : list) {
                rslt.add(groupsTree.getGroups().get(s));
            }
        }

        return rslt.iterator();
    }
146325
public OperationFuture<Group> create(GroupConfig groupConfig) {
        checkNotNull(groupConfig, "GroupConfig must be not null");
        checkNotNull(groupConfig.getName(), "Name of GroupConfig must be not null");
        checkNotNull(groupConfig.getParentGroup(), "ParentGroup of GroupConfig must be not null");

        GroupMetadata group = client.createGroup(
                converter.createGroupRequest(groupConfig, idByRef(groupConfig.getParentGroup()),
                    groupConfig.getCustomFields() == null || groupConfig.getCustomFields().size() == 0 ?
                        null : client.getCustomFields()
                ));

        return new OperationFuture<>(
            Group.refById(group.getId()),
            new NoWaitingJobFuture()
        );
    }
798592
public Object toBean(final String group, Object bean) {
		return BeanUtil.fillBean(bean, new ValueProvider<String>(){

			@Override
			public Object value(String key, Type valueType) {
				final String value = getByGroup(key, group);
//				if (null != value) {
//					log.debug("Parse setting to object field [{}={}]", key, value);
//				}
				return value;
			}

			@Override
			public boolean containsKey(String key) {
				return null != getByGroup(key, group);
			}
		}, CopyOptions.create());
	}
85969
@Override
	public JobTriggerTO getTriggerInfo(String groupName, String jobName, final String triggerGroup, final String triggerName) throws SchedulerException {
		JobDetail detail = findJob(groupName, jobName);
		
		JobTriggerTO triggerTO = new JobTriggerTO();
		triggerTO.setJobGroup(groupName);
		triggerTO.setJobName(jobName);
		triggerTO.setDescription(detail.getDescription());
		
		triggerTO.setJobData(detail.getJobDataMap());
		
		if (null == triggerName) {
			return triggerTO;
		}
		Trigger trigger = findTrigger(groupName, jobName, triggerGroup, triggerName);
		triggerTO.setTriggerName(triggerName);
		triggerTO.setTriggerGroup(trigger.getKey().getGroup());
		triggerTO.setTriggerDescription(trigger.getDescription());
		
		triggerTO.setMisfireInstruction(trigger.getMisfireInstruction());
		triggerTO.setPriority(trigger.getPriority());
		triggerTO.setCalendarName(trigger.getCalendarName());
		triggerTO.setStartTime(trigger.getStartTime());
		
		if (isCronTrigger(trigger)) {
			addSimilarMisfireInstructionSet(triggerTO, null, TriggerType.CRON);
			triggerTO.setCronExpression(((CronTrigger)trigger).getCronExpression());
			triggerTO.setTimeZone(((CronTrigger)trigger).getTimeZone());
		} else if (trigger instanceof SimpleTrigger) {
			addSimpleMisfireInstructionSet(triggerTO, null);
			triggerTO.setRepeatCount(((SimpleTrigger)trigger).getRepeatCount());
			triggerTO.setRepeatInterval(((SimpleTrigger)trigger).getRepeatInterval());
		} else if (trigger instanceof CalendarIntervalTrigger) {
			addSimilarMisfireInstructionSet(triggerTO, null, TriggerType.CALENDAR);
			triggerTO.setRepeatInterval(Long.valueOf(((CalendarIntervalTrigger)trigger).getRepeatInterval()));
			triggerTO.setRepeatIntervalUnit(((CalendarIntervalTrigger)trigger).getRepeatIntervalUnit());
		} else if (trigger instanceof DailyTimeIntervalTrigger) {
			addSimilarMisfireInstructionSet(triggerTO, null, TriggerType.DAILY);
			triggerTO.setRepeatInterval(Long.valueOf(((DailyTimeIntervalTrigger)trigger).getRepeatInterval()));
			triggerTO.setRepeatIntervalUnit(((DailyTimeIntervalTrigger)trigger).getRepeatIntervalUnit());
			triggerTO.setRepeatCount(((DailyTimeIntervalTrigger)trigger).getRepeatCount());
		}
		
		triggerTO.setJobData(trigger.getJobDataMap());
		
		addGlobalMisfireInstructionSet(triggerTO, null);
		
		return triggerTO;
	}