/**
* @param clusterId
* @param hostName
*/
@Transactional
public void removeHost(final long clusterId, String hostName) {
populateCache();
Set<HostConfigMapping> set = hostConfigMappingByHost.get(hostName);
// Remove from cache items with clusterId
CollectionUtils.filter(
set,
new Predicate() {
@Override
public boolean evaluate(Object arg0) {
return !((HostConfigMapping) arg0).getClusterId().equals(clusterId);
}
});
// delete from db
TypedQuery<HostConfigMappingEntity> query =
entityManagerProvider
.get()
.createQuery(
"SELECT entity FROM HostConfigMappingEntity entity "
+ "WHERE entity.clusterId = ?1 AND entity.hostName = ?2",
HostConfigMappingEntity.class);
List<HostConfigMappingEntity> list =
daoUtils.selectList(query, Long.valueOf(clusterId), hostName);
for (HostConfigMappingEntity entity : list) {
entityManagerProvider.get().remove(entity);
}
}
@RequiresSession
public Set<HostConfigMapping> findSelectedByHosts(long clusterId, Collection<String> hostNames) {
populateCache();
if (hostNames == null || hostNames.isEmpty()) {
return Collections.emptySet();
}
HashSet<HostConfigMapping> result = new HashSet<HostConfigMapping>();
for (final String hostName : hostNames) {
if (!hostConfigMappingByHost.containsKey(hostName)) continue;
Set<HostConfigMapping> set =
new HashSet<HostConfigMapping>(hostConfigMappingByHost.get(hostName));
CollectionUtils.filter(
set,
new Predicate() {
@Override
public boolean evaluate(Object arg0) {
return ((HostConfigMapping) arg0).getHostName().equals(hostName)
&& ((HostConfigMapping) arg0).getSelected() > 0;
}
});
result.addAll(set);
}
return result;
}
@RequiresSession
public Set<HostConfigMapping> findByType(
final long clusterId, String hostName, final String type) {
populateCache();
if (!hostConfigMappingByHost.containsKey(hostName)) return Collections.emptySet();
Set<HostConfigMapping> set =
new HashSet<HostConfigMapping>(hostConfigMappingByHost.get(hostName));
CollectionUtils.filter(
set,
new Predicate() {
@Override
public boolean evaluate(Object arg0) {
return ((HostConfigMapping) arg0).getClusterId().equals(clusterId)
&& ((HostConfigMapping) arg0).getType().equals(type);
}
});
return set;
}
@Override
public AtlasStructDefs search(SearchFilter filter) throws AtlasBaseException {
if (LOG.isDebugEnabled()) {
LOG.debug("==> AtlasStructDefStoreV1.search({})", filter);
}
List<AtlasStructDef> structDefs = new ArrayList<>();
Iterator<AtlasVertex> vertices = typeDefStore.findTypeVerticesByCategory(TypeCategory.STRUCT);
while (vertices.hasNext()) {
AtlasVertex vertex = vertices.next();
AtlasStructDef structDef = toStructDef(vertex);
if (structDef != null) {
structDefs.add(structDef);
}
}
CollectionUtils.filter(structDefs, FilterUtil.getPredicateFromSearchFilter(filter));
AtlasStructDefs ret = new AtlasStructDefs(structDefs);
if (LOG.isDebugEnabled()) {
LOG.debug("<== AtlasStructDefStoreV1.search({}): {}", filter, ret);
}
return ret;
}
/** As per enhancement added new group b2bviewergroup */
public void populateRolesByCustomer(final String uuid, final CustomerData target) {
final List<String> roles = new ArrayList<String>();
final EnergizerB2BCustomerModel model =
userService.getUserForUID(uuid, EnergizerB2BCustomerModel.class);
final Set<PrincipalGroupModel> roleModels = new HashSet<PrincipalGroupModel>(model.getGroups());
CollectionUtils.filter(
roleModels,
PredicateUtils.notPredicate(PredicateUtils.instanceofPredicate(B2BUnitModel.class)));
CollectionUtils.filter(
roleModels,
PredicateUtils.notPredicate(PredicateUtils.instanceofPredicate(B2BUserGroupModel.class)));
for (final PrincipalGroupModel role : roleModels) {
// only display allowed usergroups
if (energizerGroupsLookUpStrategy.getUserGroups().contains(role.getUid())) {
roles.add(role.getUid());
}
}
target.setRoles(roles);
}
public List<String> getAvailablePhoneNumbers() {
List<String> phoneNumbers =
Arrays.asList(
phoneNumber, additionalPhoneNumber1, additionalPhoneNumber2, additionalPhoneNumber3);
phoneNumbers = new ArrayList<String>(phoneNumbers);
CollectionUtils.filter(
phoneNumbers,
new Predicate() {
public boolean evaluate(Object input) {
if (input instanceof String) {
return StringUtils.isNotBlank((String) input);
}
return false;
}
});
return phoneNumbers;
}
@Test
public void shouldReturnOnlyStreamResources() {
List<Content> contents = getContents();
List<ResourceDto> expected = createInputData(contents);
CollectionUtils.filter(
expected,
new Predicate() {
@Override
public boolean evaluate(Object object) {
return object instanceof ResourceDto
&& !equalsIgnoreCase(((ResourceDto) object).getType(), "string");
}
});
List<ResourceDto> actual =
ResourceFilter.filter(createGridSettings("", false, true, ""), contents);
assertEquals(expected, actual);
}
/**
* Returns a map ambience -> set of files.
*
* @param global initial set of files to consider
* @return a map ambience -> set of files
*/
@SuppressWarnings("unchecked")
private Map<Ambience, List<File>> getAmbienceFilesList(List<File> global) {
// Create a map ambience -> set of files
Map<Ambience, List<File>> hmAmbienceFiles = new HashMap<Ambience, List<File>>(5);
// For performance, we find unique ambiences in from and to transitions
Set<Ambience> ambiences = new HashSet<Ambience>(5);
for (Transition tr : transitions) {
ambiences.add(tr.getFrom());
ambiences.add(tr.getTo());
}
// Fill null key
hmAmbienceFiles.put(null, (List<File>) ((ArrayList<File>) global).clone());
// Fill all ambiences
for (Ambience ambience : ambiences) {
List<File> all = (List<File>) ((ArrayList<File>) global).clone();
CollectionUtils.filter(all, new JajukPredicates.AmbiencePredicate(ambience));
hmAmbienceFiles.put(ambience, all);
}
return hmAmbienceFiles;
}
/**
* Executes a <code>HibernateQuery</code> using the currently defined <code>
* CriteriaSearchParameter</code>s, and returns a java.util.List containing the query results.
*
* @return result The result of the query.
* @throws org.hibernate.HibernateException
*/
public final java.util.List executeAsList() throws org.hibernate.HibernateException {
// add ordering
if (this.orderList.size() > 0) {
java.util.Collections.sort(this.orderList, new ParameterComparator());
for (java.util.Iterator orderIterator = this.orderList.iterator();
orderIterator.hasNext(); ) {
CriteriaSearchParameter parameter = (CriteriaSearchParameter) orderIterator.next();
int direction = parameter.getOrderDirection();
if (direction == CriteriaSearchParameter.ORDER_ASC) {
this.rootCriteria.addOrder(
org.hibernate.criterion.Order.asc(parameter.getParameterPattern()));
} else {
this.rootCriteria.addOrder(
org.hibernate.criterion.Order.desc(parameter.getParameterPattern()));
}
}
}
// set the first result if configured
if (this.configuration.getFirstResult() != null) {
this.rootCriteria.setFirstResult(this.configuration.getFirstResult().intValue());
}
// set the fetch size if configured
if (this.configuration.getFetchSize() != null) {
this.rootCriteria.setFetchSize(this.configuration.getFetchSize().intValue());
}
// limit the maximum result if configured
if (this.configuration.getMaximumResultSize() != null) {
this.rootCriteria.setMaxResults(this.configuration.getMaximumResultSize().intValue());
}
// Hibernate does not support a 'unique' identifier. As a search may contain outer joins,
// duplicates in the resultList are possible. We eliminate any duplicates here, creating a
// distinctified resultSet (Suggestion from Hibernate itself; see www.hibernate.org's FAQ's).
final java.util.List result = this.rootCriteria.list();
org.apache.commons.collections.CollectionUtils.filter(
result, org.apache.commons.collections.functors.UniquePredicate.getInstance());
return result;
}
@Test
public void shouldReturnOnlyWithGivenName() {
final String givenName = "files";
List<Content> contents = getContents();
List<ResourceDto> expected = createInputData(contents);
CollectionUtils.filter(
expected,
new Predicate() {
@Override
public boolean evaluate(Object object) {
return object instanceof ResourceDto
&& startsWithIgnoreCase(((ResourceDto) object).getName(), givenName);
}
});
List<ResourceDto> actual =
ResourceFilter.filter(createGridSettings(givenName, true, true, ""), contents);
assertEquals(expected, actual);
}
public ITargetDefinition saveMavenTargetDefinition(
Shell shell, IProject targetProject, MavenBundleContainer mavenBundleContainer) {
try {
ITargetDefinition newTarget = loadMavenTargetDefinition(mavenBundleContainer);
IFile targetFile = targetProject.getFile(PDE_TARGET_TARGET);
// Ensure plugins folder is reset
IFolder pluginsFolder = targetProject.getFolder(PDE_TARGET_PLUGINS);
if (pluginsFolder.exists()) {
pluginsFolder.delete(true, null);
}
pluginsFolder.create(true, true, null);
// Ensure otherPlugins folder exists
IFolder otherPluginsFolder = targetProject.getFolder(PDE_TARGET_OTHER_PLUGINS);
if (!otherPluginsFolder.exists()) {
otherPluginsFolder.create(true, true, null);
}
File pluginsFolderFile = pluginsFolder.getLocation().toFile();
// Copy all maven dependencies in pluginsFolder
// Keep all project artifactIds to ensure they are used instead of any other dependencies
final HashSet<String> projectArtifactId = new HashSet<String>();
for (IMavenProjectFacade mavenProject : mavenBundleContainer.getMavenProjects()) {
projectArtifactId.add(mavenProject.getArtifactKey().getArtifactId());
}
Collection<Artifact> mostRecentArtifacts =
getMostRecentArtifacts(mavenBundleContainer.getArtifacts(null));
CollectionUtils.filter(
mostRecentArtifacts,
new Predicate() {
@Override
public boolean evaluate(Object param) {
Artifact artifact = (Artifact) param;
return !projectArtifactId.contains(artifact.getArtifactId());
}
});
for (Artifact artifact : mostRecentArtifacts) {
try {
File bundleFile = artifact.getFile().getAbsoluteFile();
if (bundleFile.isFile()) {
FileUtils.copyFileToDirectory(bundleFile, pluginsFolderFile);
}
} catch (IOException e) {
throw e;
}
}
// Update targetFile with the DirectoryBundelContainer if not already present
ITargetHandle targetHandle = targetPlatformService.getTarget(targetFile);
ITargetDefinition directoryTargetDefinition = targetHandle.getTargetDefinition();
String pluginsFolderPath = pluginsFolderFile.getAbsolutePath();
String otherPluginsPath = otherPluginsFolder.getLocation().toFile().getAbsolutePath();
if (targetFile.exists()) {
// Find already existing DirectoryBundleContainer for maven repository path
addBundleContainerToTargetDefinitionIfNotPresent(
directoryTargetDefinition, pluginsFolderPath);
addBundleContainerToTargetDefinitionIfNotPresent(
directoryTargetDefinition, otherPluginsPath);
} else {
directoryTargetDefinition.setBundleContainers(
new IBundleContainer[] {
new DirectoryBundleContainer(pluginsFolderPath),
new DirectoryBundleContainer(otherPluginsPath)
});
}
// Refresh project folder tree
NullProgressMonitor monitor = new NullProgressMonitor();
targetFile.refreshLocal(IResource.DEPTH_INFINITE, monitor);
pluginsFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor);
otherPluginsFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor);
targetProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);
// Save target definition
targetPlatformService.saveTargetDefinition(directoryTargetDefinition);
LoadTargetDefinitionJob.load(directoryTargetDefinition);
return newTarget;
} catch (Exception e) {
MessageBox msgbox = new MessageBox(shell, SWT.ALPHA);
msgbox.setMessage(
"Unable to create PDE Target, delelete file " + PDE_TARGET_TARGET + " in your project");
msgbox.setText("Error while creating PDE Target");
msgbox.open();
e.printStackTrace();
throw new RuntimeException("Unable to create target", e);
}
}
