How to use

ApplicationServerContainer

in

ch.puzzle.itc.mobiliar.common.util

public boolean isAppServerContainer() {
  return ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName().equals(getName());
}

    ResourceGroupEntity.class);
q.setParameter("typePram", typeParamValue);
q.setParameter("asContainer", ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
if (!CollectionUtils.isEmpty(myAmw)) {
  q.setParameter("myAmw", myAmw);

public List<ResourceEntity> getAppServerResourcesWithApplications(String filter, Integer maxResults,
                                 List<Integer> myAmw, boolean withAppServerContainer) {
  List<ResourceEntity> appServerList = getApplicationServerResources(filter, maxResults, myAmw);
  for (ResourceEntity as : appServerList) {
    if (as.getName().equals(ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName())) {
      if (!withAppServerContainer || as.getConsumedMasterRelations().size() == 0) {
        appServerList.remove(as);
        break;
      }
    }
  }
  return appServerList;
}

/**
 * Listet Applications auf alphabetic sorted
 *
 * @return
 * @throws ch.puzzle.itc.mobiliar.common.exception.GeneralDBException
 */
public List<Application> getAllApplicationsNotBelongingToAServer() {
  List<Application> allApplications = new ArrayList<>();
  Query query = entityManager
      .createQuery(
          "select resEnt from ResourceEntity resEnt left join fetch resEnt.resourceGroup rg left join fetch rg.resources otherRes left join fetch resEnt.contexts left join fetch resEnt.consumedSlaveRelations as resConsSlaveRel left join fetch resConsSlaveRel.masterResource as master where master.name=:name order by resEnt.name")
      .setParameter("name", ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
  List<ResourceEntity> allApplicationsResourceEntities = QueryUtils.fetch(ResourceEntity.class,
      query, 0, -1);
  ContextEntity ctx = context.getGlobalResourceContextEntity();
  for (ResourceEntity resourceEntity : allApplicationsResourceEntities) {
    Application application = Application.createByResource(resourceEntity, resourceTypeProvider,
        ctx);
    allApplications.add(application);
  }
  return allApplications;
}

/**
 * @param resourceTypeName
 * @param myAmw
 * @return
 */
public List<ResourceGroupEntity> loadGroupsForTypeName(String resourceTypeName, List<Integer> myAmw) {
  List<ResourceGroupEntity> result = new ArrayList<>();
  CriteriaBuilder cb = entityManager.getCriteriaBuilder();
  CriteriaQuery<ResourceGroupEntity> q = cb.createQuery(ResourceGroupEntity.class);
  Root<ResourceGroupEntity> r = q.from(ResourceGroupEntity.class);
  r.fetch("resources");
  Join<ResourceGroupEntity, ResourceEntity> resources = r.join("resources");
  Predicate typeNamePred = cb.equal(resources.get("resourceType").get("name"), resourceTypeName);
  Predicate asContainerPred = cb.notEqual(resources.get("name"),
      ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
  if (myAmw != null && !myAmw.isEmpty()) {
    Predicate myAmwPred = r.get("id").in(myAmw);
    q.where(cb.and(cb.and(typeNamePred, asContainerPred), myAmwPred));
  }
  else {
    q.where(cb.and(typeNamePred, asContainerPred));
  }
  q.distinct(true);
  result = entityManager.createQuery(q).getResultList();
  return result;
}

public ConsumedResourceRelationEntity getConsumedSlaveRelation(final ResourceEntity relatedResource) {
  if (getConsumedSlaveRelations() != null) {
    for (final ConsumedResourceRelationEntity relation : getConsumedSlaveRelations()) {
      if (relation.getMasterResource() != null && relation.getMasterResource().getId() != null) {
        if (relatedResource.getName() != null
            && relation.getMasterResource().getId().equals(relatedResource.getId())
            && !relatedResource.getName().equals(
                ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName())) {
          return relation;
        }
      }
    }
  }
  return null;
}

/**
 * Gibt ApplicationCollectorGroup Resource zurück. Falls diese noch nicht
 * existiert, so wird die Gruppe erstellt. Diese Gruppe wird für alle
 * Applikationen zugewiesen, für welche nach löschen ihrer
 * Applikationsgruppen keine Gruppe mehr zugewiesen sind.
 *
 * @return
 */
public ApplicationServer createOrGetApplicationCollectorServer()  {
  ApplicationServer result;
  ResourceEntity appServerResource = getUniqueResourceByNameAndType(
      ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName(), DefaultResourceTypeDefinition.APPLICATIONSERVER.name());
  if (appServerResource == null) {
    result = ApplicationServer.createByName(ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName(), resourceTypeProvider, contextDomainService.getGlobalResourceContextEntity());
    result.getEntity().setDeletable(false);
    result.getEntity().setRelease(releaseMgmt.getDefaultRelease());
    entityManager.persist(result.getEntity());
  } else {
    result = ApplicationServer.createByResource(appServerResource, resourceTypeProvider, contextDomainService.getGlobalResourceContextEntity());
  }
  return result;
}

private ResourceEntity resolveApplicationServerFromResource(ResourceEntity ppiResource, ReleaseEntity targetRelease, AMWTemplateExceptionHandler templateExceptionHandler) {
  List<ResourceEntity> applications = ppiResource.getMasterResourcesOfProvidedSlaveRelationByResourceType(DefaultResourceTypeDefinition.APPLICATION);
  
  Set<ResourceGroupEntity> resourceGroupsForApplications = getResourceGroupsForResources(applications);
  if(resourceGroupsForApplications == null || resourceGroupsForApplications.isEmpty()){
    templateExceptionHandler.addTemplatePropertyException(new TemplatePropertyException("no Applications found for PPI with softlink ID: " + ppiResource.getSoftlinkId() + " in Release: " + targetRelease.getName(), 
        TemplatePropertyException.CAUSE.WRONG_DATASTRUCTURE));
  }else if(resourceGroupsForApplications.size() > 1){
    templateExceptionHandler.addTemplatePropertyException(new TemplatePropertyException("The PPI " + ppiResource.getName() + " is provided by more than one Application.", 
        TemplatePropertyException.CAUSE.WRONG_DATASTRUCTURE));
  }else{
    ResourceEntity application = dependencyResolver.getResourceEntityForRelease(resourceGroupsForApplications.iterator().next(), targetRelease);
    if(application != null){
      List<ResourceEntity> applicationServers = application.getMasterResourcesOfConsumedSlaveRelationByResourceType(DefaultResourceTypeDefinition.APPLICATIONSERVER);
      ResourceEntity applicationServer = findResourceEntityForRelease(application, applicationServers, targetRelease);
      // exclude Apps without AS ApplicationServer
      if(!ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName().equals(applicationServer.getName())){
        return applicationServer;
      }
    }
    templateExceptionHandler.addTemplatePropertyException(new TemplatePropertyException("The PPI " + ppiResource.getName() + " has no AS.", 
        TemplatePropertyException.CAUSE.WRONG_DATASTRUCTURE));
  }
  return null;
}

private void init() {
  // ResourceTypes
  type1 = resourceTypeProvider.getOrCreateDefaultResourceType(DefaultResourceTypeDefinition.APPLICATIONSERVER);
  entityManager.persist(type1);
  type2 = resourceTypeProvider.getOrCreateDefaultResourceType(DefaultResourceTypeDefinition.APPLICATION);
  entityManager.persist(type2);
  // Resources
  resource1 = ResourceFactory.createNewResource("Z");
  resource1.setResourceType(type1);
  entityManager.persist(resource1);
  resource2 = ResourceFactory.createNewResource(resource1.getResourceGroup());
  resource2.setResourceType(type1);
  entityManager.persist(resource2);
  resource3 = ResourceFactory.createNewResource("D");
  resource3.setResourceType(type2);
  entityManager.persist(resource3);
  resource4 = ResourceFactory.createNewResource("C");
  resource4.setResourceType(type1);
  entityManager.persist(resource4);
  asContainer = ResourceFactory.createNewResource(ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
  asContainer.setResourceType(type1);
  entityManager.persist(asContainer);
}

private void init() {
  // ResourceTypes
  type1 = resourceTypeProvider.getOrCreateDefaultResourceType(DefaultResourceTypeDefinition.APPLICATIONSERVER);
  entityManager.persist(type1);
  type2 = resourceTypeProvider.getOrCreateDefaultResourceType(DefaultResourceTypeDefinition.APPLICATION);
  entityManager.persist(type2);
  // Resources
  resource1 = ResourceFactory.createNewResource("Z");
  resource1.setResourceType(type1);
  entityManager.persist(resource1);
  resource2 = ResourceFactory.createNewResource(resource1.getResourceGroup());
  resource2.setResourceType(type1);
  entityManager.persist(resource2);
  resource3 = ResourceFactory.createNewResource("D");
  resource3.setResourceType(type2);
  entityManager.persist(resource3);
  resource4 = ResourceFactory.createNewResource("C");
  resource4.setResourceType(type1);
  entityManager.persist(resource4);
  asContainer = ResourceFactory.createNewResource(ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
  asContainer.setResourceType(type1);
  entityManager.persist(asContainer);
}

@Test
public void testGetConsumedSlaveRelationWithWrongResource() {
  prepareConsumedSlaveRelationTest();
  final ResourceEntity queryEntity = ResourceFactory.createNewResource(ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
  queryEntity.setId(12);
  assertNull(resourceEntity.getConsumedSlaveRelation(queryEntity));
}

@Test
public void testGetConsumedSlaveRelationWithAppserverDisplayName() {
  prepareConsumedSlaveRelationTest();
  ResourceEntity queryEntity = ResourceFactory.createNewResource(ApplicationServerContainer.APPSERVERCONTAINER.getDisplayName());
  queryEntity.setId(11);
  assertNull(resourceEntity.getConsumedSlaveRelation(queryEntity));
}