Example usage for org.apache.commons.lang BooleanUtils isTrue

List of usage examples for org.apache.commons.lang BooleanUtils isTrue

Introduction

In this page you can find the example usage for org.apache.commons.lang BooleanUtils isTrue.

Prototype

public static boolean isTrue(Boolean bool) 

Source Link

Document

Checks if a Boolean value is true, handling null by returning false.

 BooleanUtils.isTrue(Boolean.TRUE)  = true BooleanUtils.isTrue(Boolean.FALSE) = false BooleanUtils.isTrue(null)          = false 

Usage

From source file:com.wineaccess.winerypermit.WineryPermitHelper.java

/**
 * @param sellInAltStatesModel/*from  w ww  . j a  va  2 s  .c  o m*/
 * @param string 
 */
private void validateSellInAltModel(SellInAltStatesModel sellInAltStatesModel, String wineryId) {

    Boolean isOptionSelectedKachinaAlt = BooleanUtils
            .toBoolean(sellInAltStatesModel.getIsOptionSelectedKachinaAlt());
    OptionSelectedAltStates optionSelectedAltStates = sellInAltStatesModel.getOptionSelectedAltStates();
    Boolean isOptionSelectedNoPermit = BooleanUtils
            .toBoolean(sellInAltStatesModel.getIsOptionSelectedNoPermit());
    Boolean isSelectedAltStates = BooleanUtils.toBoolean(sellInAltStatesModel.getIsSelected());

    if (BooleanUtils.isTrue(isSelectedAltStates) && BooleanUtils.isNotTrue(isOptionSelectedKachinaAlt)
            && optionSelectedAltStates == null && BooleanUtils.isNotTrue(isOptionSelectedNoPermit)) {
        response.addError(new WineaccessError(SystemErrorCode.PERMIT_NO_OPTION_SELECTED_WINERY_LICENCES_ERROR,
                SystemErrorCode.PERMIT_NO_OPTION_SELECTED_WINERY_LICENCES_ERROR_TEXT));
    } else if ((BooleanUtils.isTrue(isOptionSelectedKachinaAlt) && optionSelectedAltStates != null)
            || BooleanUtils.isTrue(isOptionSelectedKachinaAlt) && BooleanUtils.isTrue(isOptionSelectedNoPermit)
            || BooleanUtils.isTrue(isOptionSelectedNoPermit) && optionSelectedAltStates != null) {
        response.addError(new WineaccessError(SystemErrorCode.PERMIT_MORE_THAN_ONE_OPTION_SELECTED_ERROR,
                SystemErrorCode.PERMIT_MORE_THAN_ONE_OPTION_SELECTED_ERROR_TEXT));
    } else {
        if (optionSelectedAltStates != null) {
            validateoptionSelectedAltstates(optionSelectedAltStates, wineryId);
        }

    }

}

From source file:com.hortonworks.streamline.streams.service.NamespaceCatalogResource.java

private Response buildNamespacesGetResponse(Collection<Namespace> namespaces, Boolean detail) {
    if (BooleanUtils.isTrue(detail)) {
        List<CatalogResourceUtil.NamespaceWithMapping> namespacesWithMapping = namespaces.stream()
                .map(namespace -> CatalogResourceUtil.enrichNamespace(namespace, environmentService))
                .collect(toList());/*ww  w .ja  va2s. c  om*/

        return WSUtils.respondEntities(namespacesWithMapping, OK);
    } else {
        return WSUtils.respondEntities(namespaces, OK);
    }
}

From source file:com.hortonworks.streamline.streams.service.NamespaceCatalogResource.java

private Response buildNamespaceGetResponse(Namespace namespace, Boolean detail) {
    if (BooleanUtils.isTrue(detail)) {
        CatalogResourceUtil.NamespaceWithMapping namespaceWithMapping = CatalogResourceUtil
                .enrichNamespace(namespace, environmentService);
        return WSUtils.respondEntity(namespaceWithMapping, OK);
    } else {/*from ww  w .  j a  v a2 s .c  o m*/
        return WSUtils.respondEntity(namespace, OK);
    }
}

From source file:jp.primecloud.auto.service.impl.LoadBalancerServiceImpl.java

/**
 * {@inheritDoc}//from   w  w w. j a v  a  2 s.  c  o m
 */
@Override
public List<LoadBalancerDto> getLoadBalancers(Long farmNo) {
    // ?
    if (farmNo == null) {
        throw new AutoApplicationException("ECOMMON-000003", "farmNo");
    }

    List<LoadBalancer> loadBalancers = loadBalancerDao.readByFarmNo(farmNo);

    // ???
    List<Long> loadBalancerNos = new ArrayList<Long>();
    for (LoadBalancer loadBalancer : loadBalancers) {
        loadBalancerNos.add(loadBalancer.getLoadBalancerNo());
    }

    // (AWS)?
    List<PlatformAws> platformAwss = platformAwsDao.readAll();
    Map<Long, PlatformAws> platformAwsMap = new LinkedHashMap<Long, PlatformAws>();
    for (PlatformAws platformAws : platformAwss) {
        platformAwsMap.put(platformAws.getPlatformNo(), platformAws);
    }

    // (VMWare)?
    List<PlatformVmware> platformVmwares = platformVmwareDao.readAll();
    Map<Long, PlatformVmware> platformVmwareMap = new LinkedHashMap<Long, PlatformVmware>();
    for (PlatformVmware platformVmware : platformVmwares) {
        platformVmwareMap.put(platformVmware.getPlatformNo(), platformVmware);
    }

    // (Nifty)?
    List<PlatformNifty> platformNifties = platformNiftyDao.readAll();
    Map<Long, PlatformNifty> platformNiftyMap = new LinkedHashMap<Long, PlatformNifty>();
    for (PlatformNifty platformNifty : platformNifties) {
        platformNiftyMap.put(platformNifty.getPlatformNo(), platformNifty);
    }

    // (CloudStack)?
    List<PlatformCloudstack> platformCloudstacks = platformCloudstackDao.readAll();
    Map<Long, PlatformCloudstack> platformCloudstackMap = new LinkedHashMap<Long, PlatformCloudstack>();
    for (PlatformCloudstack platformCloudstack : platformCloudstacks) {
        platformCloudstackMap.put(platformCloudstack.getPlatformNo(), platformCloudstack);
    }

    // (Vcloud)?
    List<PlatformVcloud> platformVclouds = platformVcloudDao.readAll();
    Map<Long, PlatformVcloud> platformVcloudMap = new LinkedHashMap<Long, PlatformVcloud>();
    for (PlatformVcloud platformVcloud : platformVclouds) {
        platformVcloudMap.put(platformVcloud.getPlatformNo(), platformVcloud);
    }

    // (Azure)?
    List<PlatformAzure> platformAzures = platformAzureDao.readAll();
    Map<Long, PlatformAzure> platformAzureMap = new LinkedHashMap<Long, PlatformAzure>();
    for (PlatformAzure platformAzure : platformAzures) {
        platformAzureMap.put(platformAzure.getPlatformNo(), platformAzure);
    }

    // ?
    List<Platform> platforms = platformDao.readAll();

    // PlatformDto?
    Map<Long, PlatformDto> platformDtoMap = new LinkedHashMap<Long, PlatformDto>();
    for (Platform platform : platforms) {
        PlatformDto platformDto = new PlatformDto();
        platformDto.setPlatform(platform);
        platformDto.setPlatformAws(platformAwsMap.get(platform.getPlatformNo()));
        platformDto.setPlatformCloudstack(platformCloudstackMap.get(platform.getPlatformNo()));
        platformDto.setPlatformVmware(platformVmwareMap.get(platform.getPlatformNo()));
        platformDto.setPlatformNifty(platformNiftyMap.get(platform.getPlatformNo()));
        platformDto.setPlatformVcloud(platformVcloudMap.get(platform.getPlatformNo()));
        platformDto.setPlatformAzure(platformAzureMap.get(platform.getPlatformNo()));
        platformDtoMap.put(platform.getPlatformNo(), platformDto);
    }

    // (AWS)?
    List<ImageAws> imageAwses = imageAwsDao.readAll();
    Map<Long, ImageAws> imageAwsMap = new LinkedHashMap<Long, ImageAws>();
    for (ImageAws imageAws : imageAwses) {
        imageAwsMap.put(imageAws.getImageNo(), imageAws);
    }

    // (Cloudstack)?
    List<ImageCloudstack> imageCloudstacks = imageCloudstackDao.readAll();
    Map<Long, ImageCloudstack> imageCloudstackMap = new LinkedHashMap<Long, ImageCloudstack>();
    for (ImageCloudstack imageCloudstack : imageCloudstacks) {
        imageCloudstackMap.put(imageCloudstack.getImageNo(), imageCloudstack);
    }

    // (VMWare)?
    List<ImageVmware> imageVmwares = imageVmwareDao.readAll();
    Map<Long, ImageVmware> imageVmwareMap = new LinkedHashMap<Long, ImageVmware>();
    for (ImageVmware imageVmware : imageVmwares) {
        imageVmwareMap.put(imageVmware.getImageNo(), imageVmware);
    }

    // (Nifty)?
    List<ImageNifty> imageNifties = imageNiftyDao.readAll();
    Map<Long, ImageNifty> imageNiftyMap = new LinkedHashMap<Long, ImageNifty>();
    for (ImageNifty imageNifty : imageNifties) {
        imageNiftyMap.put(imageNifty.getImageNo(), imageNifty);
    }

    // (VCloud)?
    List<ImageVcloud> imageVclouds = imageVcloudDao.readAll();
    Map<Long, ImageVcloud> imageVcloudMap = new LinkedHashMap<Long, ImageVcloud>();
    for (ImageVcloud imageVcloud : imageVclouds) {
        imageVcloudMap.put(imageVcloud.getImageNo(), imageVcloud);
    }

    // (Azure)?
    List<ImageAzure> imageAzures = imageAzureDao.readAll();
    Map<Long, ImageAzure> imageAzureMap = new LinkedHashMap<Long, ImageAzure>();
    for (ImageAzure imageAzure : imageAzures) {
        imageAzureMap.put(imageAzure.getImageNo(), imageAzure);
    }

    // ?
    List<Image> images = imageDao.readAll();

    // ImageDto?
    Map<Long, ImageDto> imageDtoMap = new LinkedHashMap<Long, ImageDto>();
    for (Image image : images) {
        ImageDto imageDto = new ImageDto();
        imageDto.setImage(image);
        imageDto.setImageAws(imageAwsMap.get(image.getImageNo()));
        imageDto.setImageVmware(imageVmwareMap.get(image.getImageNo()));
        imageDto.setImageCloudstack(imageCloudstackMap.get(image.getImageNo()));
        imageDto.setImageNifty(imageNiftyMap.get(image.getImageNo()));
        imageDto.setImageVcloud(imageVcloudMap.get(image.getImageNo()));
        imageDto.setImageAzure(imageAzureMap.get(image.getImageNo()));
        imageDtoMap.put(image.getImageNo(), imageDto);
    }

    // AWS??
    List<AwsLoadBalancer> awsLoadBalancers = awsLoadBalancerDao.readInLoadBalancerNos(loadBalancerNos);
    Map<Long, AwsLoadBalancer> awsLoadBalancerMap = new LinkedHashMap<Long, AwsLoadBalancer>();
    for (AwsLoadBalancer awsLoadBalancer : awsLoadBalancers) {
        awsLoadBalancerMap.put(awsLoadBalancer.getLoadBalancerNo(), awsLoadBalancer);
    }

    // CloudStack??
    List<CloudstackLoadBalancer> cloudstackLoadBalancers = cloudstackLoadBalancerDao
            .readInLoadBalancerNos(loadBalancerNos);
    Map<Long, CloudstackLoadBalancer> cloudstackLoadBalancerMap = new LinkedHashMap<Long, CloudstackLoadBalancer>();
    for (CloudstackLoadBalancer cloudstackLoadBalancer : cloudstackLoadBalancers) {
        cloudstackLoadBalancerMap.put(cloudstackLoadBalancer.getLoadBalancerNo(), cloudstackLoadBalancer);
    }

    // ????
    List<ComponentLoadBalancer> componentLoadBalancers = componentLoadBalancerDao
            .readInLoadBalancerNos(loadBalancerNos);
    Map<Long, ComponentLoadBalancer> componentLoadBalancerMap = new LinkedHashMap<Long, ComponentLoadBalancer>();
    for (ComponentLoadBalancer componentLoadBalancer : componentLoadBalancers) {
        componentLoadBalancerMap.put(componentLoadBalancer.getLoadBalancerNo(), componentLoadBalancer);
    }

    // ?
    List<LoadBalancerListener> allListeners = loadBalancerListenerDao.readInLoadBalancerNos(loadBalancerNos);
    Map<Long, List<LoadBalancerListener>> listenersMap = new LinkedHashMap<Long, List<LoadBalancerListener>>();
    for (LoadBalancerListener listener : allListeners) {
        List<LoadBalancerListener> listeners = listenersMap.get(listener.getLoadBalancerNo());
        if (listeners == null) {
            listeners = new ArrayList<LoadBalancerListener>();
            listenersMap.put(listener.getLoadBalancerNo(), listeners);
        }
        listeners.add(listener);
    }

    // ??
    List<LoadBalancerHealthCheck> allHealthChecks = loadBalancerHealthCheckDao
            .readInLoadBalancerNos(loadBalancerNos);
    Map<Long, LoadBalancerHealthCheck> healthCheckMap = new LinkedHashMap<Long, LoadBalancerHealthCheck>();
    for (LoadBalancerHealthCheck healthCheck : allHealthChecks) {
        healthCheckMap.put(healthCheck.getLoadBalancerNo(), healthCheck);
    }

    // ?
    List<AutoScalingConf> autoScalingConfs = autoScalingConfDao.readInLoadBalancerNos(loadBalancerNos);
    Map<Long, AutoScalingConf> autoScalingConfMap = new LinkedHashMap<Long, AutoScalingConf>();
    for (AutoScalingConf autoScalingConf : autoScalingConfs) {
        autoScalingConfMap.put(autoScalingConf.getLoadBalancerNo(), autoScalingConf);
    }

    // ??
    List<LoadBalancerInstance> allLbInstances = loadBalancerInstanceDao.readInLoadBalancerNos(loadBalancerNos);
    Map<Long, List<LoadBalancerInstance>> lbInstancesMap = new LinkedHashMap<Long, List<LoadBalancerInstance>>();
    for (LoadBalancerInstance lbInstance : allLbInstances) {
        List<LoadBalancerInstance> lbInstances = lbInstancesMap.get(lbInstance.getLoadBalancerNo());
        if (lbInstances == null) {
            lbInstances = new ArrayList<LoadBalancerInstance>();
            lbInstancesMap.put(lbInstance.getLoadBalancerNo(), lbInstances);
        }
        lbInstances.add(lbInstance);
    }

    // ?
    Set<Long> targetInstanceNos = new HashSet<Long>();
    for (LoadBalancerInstance lbInstance : allLbInstances) {
        targetInstanceNos.add(lbInstance.getInstanceNo());
    }
    List<Instance> targetInstances = instanceDao.readInInstanceNos(targetInstanceNos);
    Map<Long, Instance> targetInstanceMap = new HashMap<Long, Instance>();
    for (Instance targetInstance : targetInstances) {
        targetInstanceMap.put(targetInstance.getInstanceNo(), targetInstance);
    }

    List<LoadBalancerDto> dtos = new ArrayList<LoadBalancerDto>();
    for (LoadBalancer loadBalancer : loadBalancers) {

        Long loadBalancerNo = loadBalancer.getLoadBalancerNo();
        AwsLoadBalancer awsLoadBalancer = awsLoadBalancerMap.get(loadBalancerNo);
        CloudstackLoadBalancer cloudstackLoadBalancer = cloudstackLoadBalancerMap.get(loadBalancerNo);
        ComponentLoadBalancer componentLoadBalancer = componentLoadBalancerMap
                .get(loadBalancer.getLoadBalancerNo());

        List<LoadBalancerListener> listeners = listenersMap.get(loadBalancerNo);
        if (listeners == null) {
            listeners = new ArrayList<LoadBalancerListener>();
        }

        LoadBalancerHealthCheck healthCheck = healthCheckMap.get(loadBalancerNo);

        AutoScalingConfDto autoScalingConfDto = null;
        if (BooleanUtils.toBoolean(Config.getProperty("autoScaling.useAutoScaling"))) {
            autoScalingConfDto = new AutoScalingConfDto();
            AutoScalingConf autoScalingConf = autoScalingConfMap.get(loadBalancerNo);
            autoScalingConfDto.setAutoScalingConf(autoScalingConf);
            autoScalingConfDto.setPlatform(platformDtoMap.get(autoScalingConf.getPlatformNo()));
            autoScalingConfDto.setImage(imageDtoMap.get(autoScalingConf.getImageNo()));
        }

        List<LoadBalancerInstance> lbInstances = lbInstancesMap.get(loadBalancerNo);
        if (lbInstances == null) {
            lbInstances = new ArrayList<LoadBalancerInstance>();
        }

        // ??????
        ComponentLoadBalancerDto componentLoadBalancerDto = null;
        if (componentLoadBalancer != null) {
            Component component = componentDao.read(componentLoadBalancer.getComponentNo());

            List<Long> instanceNos = new ArrayList<Long>();
            List<ComponentInstance> componentInstances = componentInstanceDao
                    .readByComponentNo(componentLoadBalancer.getComponentNo());
            for (ComponentInstance componentInstance : componentInstances) {
                instanceNos.add(componentInstance.getInstanceNo());
            }
            List<Instance> instances = instanceDao.readInInstanceNos(instanceNos);

            // IP
            String ipAddress = null;
            if (!instances.isEmpty()) {
                Boolean showPublicIp = BooleanUtils.toBooleanObject(Config.getProperty("ui.showPublicIp"));
                if (BooleanUtils.isTrue(showPublicIp)) {
                    //ui.showPublicIp = true ???URL?PublicIp
                    ipAddress = instances.get(0).getPublicIp();
                } else {
                    //ui.showPublicIp = false ???URL?PrivateIp
                    ipAddress = instances.get(0).getPrivateIp();
                }
            }

            componentLoadBalancerDto = new ComponentLoadBalancerDto();
            componentLoadBalancerDto.setComponentLoadBalancer(componentLoadBalancer);
            componentLoadBalancerDto.setComponent(component);
            componentLoadBalancerDto.setInstances(instances);
            componentLoadBalancerDto.setIpAddress(ipAddress);
        }

        // 
        Collections.sort(listeners, Comparators.COMPARATOR_LOAD_BALANCER_LISTENER);
        Collections.sort(lbInstances, Comparators.COMPARATOR_LOAD_BALANCER_INSTANCE);

        // TODO: ????????????????
        // ??
        LoadBalancerStatus status = LoadBalancerStatus.fromStatus(loadBalancer.getStatus());
        if (BooleanUtils.isTrue(loadBalancer.getEnabled())) {
            if (status == LoadBalancerStatus.STOPPED) {
                status = LoadBalancerStatus.STARTING;
            } else if (status == LoadBalancerStatus.RUNNING
                    && BooleanUtils.isTrue(loadBalancer.getConfigure())) {
                status = LoadBalancerStatus.CONFIGURING;
            }
        } else {
            if (status == LoadBalancerStatus.RUNNING || status == LoadBalancerStatus.WARNING) {
                status = LoadBalancerStatus.STOPPING;
            }
        }
        loadBalancer.setStatus(status.toString());

        // ?
        for (LoadBalancerListener listener : listeners) {
            LoadBalancerListenerStatus status2 = LoadBalancerListenerStatus.fromStatus(listener.getStatus());
            if (BooleanUtils.isTrue(loadBalancer.getEnabled()) && BooleanUtils.isTrue(listener.getEnabled())) {
                if (status2 == LoadBalancerListenerStatus.STOPPED) {
                    status2 = LoadBalancerListenerStatus.STARTING;
                } else if (status2 == LoadBalancerListenerStatus.RUNNING
                        && BooleanUtils.isTrue(listener.getConfigure())) {
                    status2 = LoadBalancerListenerStatus.CONFIGURING;
                }
            } else {
                if (status2 == LoadBalancerListenerStatus.RUNNING
                        || status2 == LoadBalancerListenerStatus.WARNING) {
                    status2 = LoadBalancerListenerStatus.STOPPING;
                }
            }
            listener.setStatus(status2.toString());
        }

        LoadBalancerDto dto = new LoadBalancerDto();
        dto.setLoadBalancer(loadBalancer);
        dto.setPlatform(platformDtoMap.get(loadBalancer.getPlatformNo()));
        dto.setAwsLoadBalancer(awsLoadBalancer);
        dto.setCloudstackLoadBalancer(cloudstackLoadBalancer);
        dto.setComponentLoadBalancerDto(componentLoadBalancerDto);
        dto.setLoadBalancerListeners(listeners);
        dto.setLoadBalancerHealthCheck(healthCheck);
        dto.setLoadBalancerInstances(lbInstances);
        dto.setAutoScalingConf(autoScalingConfDto);
        dtos.add(dto);
    }

    // 
    Collections.sort(dtos, Comparators.COMPARATOR_LOAD_BALANCER_DTO);

    return dtos;
}

From source file:jp.primecloud.auto.process.ProcessManager.java

protected boolean processStopInstances(final Farm farm) {
    // ??????/*  ww w  .java 2  s .  c om*/
    if (BooleanUtils.isTrue(farm.getComponentProcessing())) {
        return false;
    }

    // ????????????????????
    boolean coodinated = false;
    List<Instance> allInstances = instanceDao.readByFarmNo(farm.getFarmNo());
    for (Instance instance : allInstances) {
        if (InstanceStatus.fromStatus(instance.getStatus()) == InstanceStatus.RUNNING) {
            if (BooleanUtils.isNotTrue(instance.getEnabled())) {
                if (InstanceCoodinateStatus
                        .fromStatus(instance.getCoodinateStatus()) == InstanceCoodinateStatus.COODINATED) {
                    coodinated = true;
                    break;
                }
            }
        }
    }

    // ???????????????
    if (coodinated) {
        final User user = userDao.read(farm.getUserNo());
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                LoggingUtils.setUserNo(user.getMasterUser());
                LoggingUtils.setUserName(user.getUsername());
                LoggingUtils.setFarmNo(farm.getFarmNo());
                LoggingUtils.setFarmName(farm.getFarmName());
                LoggingUtils.setLoginUserNo(user.getUserNo());
                try {
                    instancesProcess.stop(farm.getFarmNo());
                } catch (MultiCauseException ignore) {
                } catch (Throwable e) {
                    log.error(e.getMessage(), e);

                    // 
                    eventLogger.error("SystemError", new Object[] { e.getMessage() });
                } finally {
                    LoggingUtils.removeContext();
                }
            }
        };
        executorService.execute(runnable);
    }

    return !coodinated;
}

From source file:jp.primecloud.auto.service.impl.InstanceServiceImpl.java

/**
 * {@inheritDoc}//  www  . j  a v a 2  s .  c  o  m
 */
@Override
public InstanceDto getInstance(Long instanceNo) {
    // ?
    Instance instance = instanceDao.read(instanceNo);

    // ZabbixInstance?
    ZabbixInstance zabbixInstance = zabbixInstanceDao.read(instanceNo);

    // ?
    Platform platform = platformDao.read(instance.getPlatformNo());

    // ?
    Image image = imageDao.read(instance.getImageNo());

    // ??????
    Map<Long, List<ComponentInstance>> componentInstanceMap = new LinkedHashMap<Long, List<ComponentInstance>>();
    componentInstanceMap.put(instanceNo, new ArrayList<ComponentInstance>());
    List<ComponentInstance> tmpComponentInstances = componentInstanceDao.readByInstanceNo(instanceNo);
    for (ComponentInstance componentInstance : tmpComponentInstances) {
        // ?????????
        if (BooleanUtils.isNotTrue(componentInstance.getAssociate())) {
            ComponentInstanceStatus status = ComponentInstanceStatus.fromStatus(componentInstance.getStatus());
            if (status == ComponentInstanceStatus.STOPPED) {
                continue;
            }
        }
        componentInstanceMap.get(componentInstance.getInstanceNo()).add(componentInstance);
    }

    // ???
    Map<Long, Component> componentMap = new HashMap<Long, Component>();
    Set<Long> componentNos = new HashSet<Long>();
    for (ComponentInstance componentInstance : tmpComponentInstances) {
        componentNos.add(componentInstance.getComponentNo());
    }
    List<Component> components = componentDao.readInComponentNos(componentNos);
    for (Component component : components) {
        componentMap.put(component.getComponentNo(), component);
    }

    // ??????
    Farm farm = farmDao.read(instance.getFarmNo());
    PlatformDto platformDto = new PlatformDto();
    platformDto.setPlatform(platform);
    ImageDto imageDto = new ImageDto();
    imageDto.setImage(image);

    AwsInstance awsInstance = null;
    AwsAddress awsAddress = null;
    List<AwsVolume> awsVolumes = null;
    AwsCertificate awsCertificate = null;

    CloudstackInstance cloudstackInstance = null;
    CloudstackAddress cloudstackAddress = null;
    List<CloudstackVolume> cloudstackVolumes = null;

    VmwareInstance vmwareInstance = null;
    VmwareAddress vmwareAddress = null;
    VmwareKeyPair vmwareKeyPair = null;
    List<VmwareDisk> vmwareDisks = null;

    NiftyInstance niftyInstance = null;
    NiftyKeyPair niftyKeyPair = null;

    VcloudInstance vcloudInstance = null;
    List<VcloudDisk> vcloudDisks = null;
    VcloudKeyPair vcloudKeyPair = null;
    List<VcloudInstanceNetwork> vcloudInstanceNetworks = null;
    PlatformVcloudStorageType platformVcloudStorageType = null;

    AzureCertificate azureCertificate = null;
    AzureInstance azureInstance = null;
    List<AzureDisk> azureDisks = null;
    // List<AzureNetwork> azureNetworks = null;
    // List<AzureStorage> azureStorages = null;

    OpenstackCertificate openstackCertificate = null;
    OpenstackInstance openstackInstance = null;

    // TODO CLOUD BRANCHING
    if (PCCConstant.PLATFORM_TYPE_AWS.equals(platform.getPlatformType())) {
        PlatformAws platformAws = platformAwsDao.read(platform.getPlatformNo());
        ImageAws imageAws = imageAwsDao.read(instance.getImageNo());
        platformDto.setPlatformAws(platformAws);
        imageDto.setImageAws(imageAws);

        // AWS?
        awsInstance = awsInstanceDao.read(instanceNo);

        // AWS?
        List<AwsAddress> awsAddresses = awsAddressDao.readByInstanceNo(instanceNo);
        for (AwsAddress address : awsAddresses) {
            awsAddress = address;
            break;
        }

        // AWS?
        awsVolumes = awsVolumeDao.readByInstanceNo(instanceNo);

        // AWS??
        awsCertificate = awsCertificateDao.read(farm.getUserNo(), instance.getPlatformNo());

    } else if (PCCConstant.PLATFORM_TYPE_CLOUDSTACK.equals(platform.getPlatformType())) {
        PlatformCloudstack platformCloudstack = platformCloudstackDao.read(platform.getPlatformNo());
        ImageCloudstack imageCloudstack = imageCloudstackDao.read(instance.getImageNo());
        platformDto.setPlatformCloudstack(platformCloudstack);
        imageDto.setImageCloudstack(imageCloudstack);

        // CloudStack?
        cloudstackInstance = cloudstackInstanceDao.read(instanceNo);

        // CloudStack?
        List<CloudstackAddress> cloudstackAddresses = cloudstackAddressDao.readByInstanceNo(instanceNo);
        for (CloudstackAddress address : cloudstackAddresses) {
            cloudstackAddress = address;
            break;
        }

        // CloudStack?
        cloudstackVolumes = cloudstackVolumeDao.readByInstanceNo(instanceNo);

    } else if (PCCConstant.PLATFORM_TYPE_VMWARE.equals(platform.getPlatformType())) {
        PlatformVmware platformVmware = platformVmwareDao.read(platform.getPlatformNo());
        ImageVmware imageVmware = imageVmwareDao.read(instance.getImageNo());
        platformDto.setPlatformVmware(platformVmware);
        imageDto.setImageVmware(imageVmware);

        // VMware?
        vmwareInstance = vmwareInstanceDao.read(instanceNo);

        // VMwareAddress?
        vmwareAddress = vmwareAddressDao.readByInstanceNo(instanceNo);

        // VMware?
        vmwareKeyPair = vmwareKeyPairDao.read(vmwareInstance.getKeyPairNo());

        // VMware?
        vmwareDisks = vmwareDiskDao.readByInstanceNo(instanceNo);

    } else if (PCCConstant.PLATFORM_TYPE_NIFTY.equals(platform.getPlatformType())) {
        PlatformNifty platformNiftie = platformNiftyDao.read(platform.getPlatformNo());
        ImageNifty imageNiftie = imageNiftyDao.read(instance.getImageNo());
        platformDto.setPlatformNifty(platformNiftie);
        imageDto.setImageNifty(imageNiftie);

        // Nifty?
        niftyInstance = niftyInstanceDao.read(instanceNo);

        // Nifty?
        niftyKeyPair = niftyKeyPairDao.read(niftyInstance.getKeyPairNo());

    } else if (PCCConstant.PLATFORM_TYPE_VCLOUD.equals(platform.getPlatformType())) {
        PlatformVcloud platformVcloud = platformVcloudDao.read(platform.getPlatformNo());
        ImageVcloud imageVcloud = imageVcloudDao.read(instance.getImageNo());
        platformDto.setPlatformVcloud(platformVcloud);
        imageDto.setImageVcloud(imageVcloud);

        // VCloudInstance?
        vcloudInstance = vcloudInstanceDao.read(instanceNo);

        // VCloudDisks?
        vcloudDisks = vcloudDiskDao.readByInstanceNo(instanceNo);

        // VCloudKeyPair?
        vcloudKeyPair = vcloudKeyPairDao.read(vcloudInstance.getKeyPairNo());

        // VCloudInstanceNetwork?
        vcloudInstanceNetworks = vcloudInstanceNetworkDao.readByInstanceNo(instanceNo);
        Collections.sort(vcloudInstanceNetworks, Comparators.COMPARATOR_VCLOUD_INSTANCE_NETWORK);

        // PlatformVCloudStrogeType?
        platformVcloudStorageType = platformVcloudStorageTypeDao.read(vcloudInstance.getStorageTypeNo());

    } else if (PCCConstant.PLATFORM_TYPE_AZURE.equals(platform.getPlatformType())) {
        PlatformAzure platformAzure = platformAzureDao.read(platform.getPlatformNo());
        ImageAzure imageAzure = imageAzureDao.read(instance.getImageNo());
        platformDto.setPlatformAzure(platformAzure);
        imageDto.setImageAzure(imageAzure);

        // AzureInstance?
        azureInstance = azureInstanceDao.read(instanceNo);

        // AzureDisks?
        azureDisks = azureDiskDao.readByInstanceNo(instanceNo);

        // Azure??
        azureCertificate = azureCertificateDao.read(farm.getUserNo(), instance.getPlatformNo());

        // AzureInstance?
        // vcloudKeyPair = vcloudKeyPairDao.read(vcloudInstance.getKeyPairNo());

        // AzureStroge?
        // platformVcloudStorageType = platformVcloudStorageTypeDao.read(vcloudInstance.getStorageTypeNo());

    } else if (PCCConstant.PLATFORM_TYPE_OPENSTACK.equals(platform.getPlatformType())) {
        PlatformOpenstack platformOpenstack = platformOpenstackDao.read(platform.getPlatformNo());
        ImageOpenstack imageOpenstack = imageOpenstackDao.read(instance.getImageNo());
        platformDto.setPlatformOpenstack(platformOpenstack);
        imageDto.setImageOpenstack(imageOpenstack);

        // OpenstackInstance?
        openstackInstance = openstackInstanceDao.read(instanceNo);

        // Openstack??
        openstackCertificate = openstackCertificateDao.read(farm.getUserNo(), instance.getPlatformNo());
    }

    List<InstanceConfig> instanceConfigs = instanceConfigDao.readByInstanceNo(instance.getInstanceNo());

    List<ComponentInstanceDto> componentInstances = new ArrayList<ComponentInstanceDto>();
    for (ComponentInstance componentInstance : componentInstanceMap.get(instance.getInstanceNo())) {
        ComponentInstanceDto componentInstanceDto = new ComponentInstanceDto();
        componentInstanceDto.setComponentInstance(componentInstance);

        Component component = componentMap.get(componentInstance.getComponentNo());
        String url;
        Boolean showPublicIp = BooleanUtils.toBooleanObject(Config.getProperty("ui.showPublicIp"));
        if (BooleanUtils.isTrue(showPublicIp)) {
            //ui.showPublicIp = true ???URL?PublicIp
            url = createUrl(instance.getPublicIp(), component.getComponentTypeNo());
        } else {
            //ui.showPublicIp = false ???URL?PrivateIp
            url = createUrl(instance.getPrivateIp(), component.getComponentTypeNo());
        }
        componentInstanceDto.setUrl(url);
        componentInstances.add(componentInstanceDto);
    }

    // ?????
    InstanceStatus instanceStatus = InstanceStatus.fromStatus(instance.getStatus());
    if (BooleanUtils.isTrue(instance.getEnabled())) {
        if (instanceStatus == InstanceStatus.STOPPED) {
            instance.setStatus(InstanceStatus.STARTING.toString());
        }
    } else {
        if (instanceStatus == InstanceStatus.RUNNING || instanceStatus == InstanceStatus.WARNING) {
            instance.setStatus(InstanceStatus.STOPPING.toString());
        }
    }

    // ???
    //    ? ?   ??
    //        Running         Coodinating            Configuring
    //        Running         Warning                Warning
    instanceStatus = InstanceStatus.fromStatus(instance.getStatus());
    InstanceCoodinateStatus insCoodiStatus = InstanceCoodinateStatus.fromStatus(instance.getCoodinateStatus());
    // ?(Running)???(Coodinating)Configuring?
    if (instanceStatus == InstanceStatus.RUNNING && insCoodiStatus == InstanceCoodinateStatus.COODINATING) {
        instance.setStatus(InstanceStatus.CONFIGURING.toString());
        // ?(Running)???(Warning)Warning?
    } else if (instanceStatus == InstanceStatus.RUNNING && insCoodiStatus == InstanceCoodinateStatus.WARNING) {
        instance.setStatus(InstanceStatus.WARNING.toString());
    }

    // ????????
    instanceStatus = InstanceStatus.fromStatus(instance.getStatus());
    for (ComponentInstanceDto componentInstanceDto : componentInstances) {
        ComponentInstance componentInstance = componentInstanceDto.getComponentInstance();
        ComponentInstanceStatus status = ComponentInstanceStatus.fromStatus(componentInstance.getStatus());
        if (BooleanUtils.isTrue(componentInstance.getEnabled())) {
            if (status == ComponentInstanceStatus.STOPPED) {
                if (instanceStatus == InstanceStatus.WARNING) {
                    // ?Waring??????Warning??
                    componentInstance.setStatus(ComponentInstanceStatus.WARNING.toString());
                } else if (BooleanUtils.isTrue(farm.getScheduled())) {
                    componentInstance.setStatus(ComponentInstanceStatus.STARTING.toString());
                }
            }
        } else {
            if (status == ComponentInstanceStatus.RUNNING || status == ComponentInstanceStatus.WARNING) {
                if (BooleanUtils.isTrue(farm.getScheduled())) {
                    // ??????Stopping??
                    componentInstance.setStatus(ComponentInstanceStatus.STOPPING.toString());
                }
            }
        }
    }

    // 
    Collections.sort(componentInstances, Comparators.COMPARATOR_COMPONENT_INSTANCE_DTO);

    //?
    // TODO CLOUD BRANCHING
    InstanceDto dto = new InstanceDto();
    dto.setInstance(instance);
    dto.setZabbixInstance(zabbixInstance);
    dto.setPlatform(platformDto);
    dto.setImage(imageDto);
    dto.setInstanceConfigs(instanceConfigs);
    dto.setComponentInstances(componentInstances);

    dto.setAwsInstance(awsInstance);
    dto.setAwsAddress(awsAddress);
    dto.setAwsVolumes(awsVolumes);
    dto.setAwsCertificate(awsCertificate);

    dto.setCloudstackInstance(cloudstackInstance);
    dto.setCloudstackAddress(cloudstackAddress);
    dto.setCloudstackVolumes(cloudstackVolumes);

    dto.setVmwareInstance(vmwareInstance);
    dto.setVmwareAddress(vmwareAddress);
    dto.setVmwareKeyPair(vmwareKeyPair);
    dto.setVmwareDisks(vmwareDisks);

    dto.setNiftyInstance(niftyInstance);
    dto.setNiftyKeyPair(niftyKeyPair);

    dto.setVcloudInstance(vcloudInstance);
    dto.setVcloudDisks(vcloudDisks);
    dto.setVcloudKeyPair(vcloudKeyPair);
    dto.setVcloudInstanceNetworks(vcloudInstanceNetworks);
    dto.setPlatformVcloudStorageType(platformVcloudStorageType);

    dto.setAzureCertificate(azureCertificate);
    dto.setAzureInstance(azureInstance);
    dto.setAzureDisks(azureDisks);

    dto.setOpenstackInstance(openstackInstance);
    dto.setOpenstackCertificate(openstackCertificate);

    return dto;
}

From source file:com.evolveum.midpoint.model.impl.lens.ChangeExecutor.java

private <O extends ObjectType> void applyObjectPolicy(LensFocusContext<O> focusContext,
        ObjectDelta<O> focusDelta, ObjectPolicyConfigurationType objectPolicyConfigurationType) {
    if (objectPolicyConfigurationType == null) {
        return;/* w w w . jav  a2  s .c om*/
    }
    PrismObject<O> objectNew = focusContext.getObjectNew();
    if (focusDelta.isAdd() && objectNew.getOid() == null) {

        for (PropertyConstraintType propertyConstraintType : objectPolicyConfigurationType
                .getPropertyConstraint()) {
            if (BooleanUtils.isTrue(propertyConstraintType.isOidBound())) {
                ItemPath itemPath = propertyConstraintType.getPath().getItemPath();
                PrismProperty<Object> prop = objectNew.findProperty(itemPath);
                String stringValue = prop.getRealValue().toString();
                focusContext.setOid(stringValue);
            }
        }

        // deprecated
        if (BooleanUtils.isTrue(objectPolicyConfigurationType.isOidNameBoundMode())) {
            String name = objectNew.asObjectable().getName().getOrig();
            focusContext.setOid(name);
        }
    }
}

From source file:com.haulmont.ext.web.ui.Call.CallBrowser.java

private void initAfterSetLookup(boolean isLookup) {
    final User user = UserSessionClient.getUserSession().getCurrentOrSubstitutedUser();
    SplitPanel splitPanel = getComponent("split");
    splitPanel.setSplitPosition(100);//from w  w  w.ja v  a  2 s  .c  o  m
    splitPanel.setLocked(true);
    if (isLookup) {
        callTable.setMultiSelect(false);
    } else if (!isTemplate) {
        //            final HashMap<UUID, com.vaadin.ui.Component> statesMap = new HashMap<UUID, com.vaadin.ui.Component>();
        final CardService cardService = ServiceLocator.lookup(CardService.NAME);
        addLocStateColumn();

        resolutionsFrame = getComponent("resolutionsFrame");
        resolutionsFrame.init();

        cardTreeFrame = getComponent("cardTreeFrame");
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("card", null);
        cardTreeFrame.init(params);

        showResolutions = getComponent(HIDE_RESOLUTIONS);
        final SplitPanel split = getComponent("split");
        showResolutions.addListener(new ValueListener() {
            public void valueChanged(Object source, String property, Object prevValue, Object value) {
                boolean showResolutionsValue = BooleanUtils.isTrue((Boolean) value);
                int pos = (!showResolutionsValue ? 100 : 60);
                split.setSplitPosition(pos);
                split.setLocked(!showResolutionsValue);

                Card card = (Card) callTable.getSingleSelected();
                if (showResolutionsValue && card != null) {
                    String currentTab = tabsheet.getTab().getName();
                    if (currentTab.equals("resolutionsTab"))
                        resolutionsFrame.setCard(card);
                    if (currentTab.equals("hierarchyTab"))
                        cardTreeFrame.setCard(card);
                }
            }
        });

        String value = getSettings().get(HIDE_RESOLUTIONS).attributeValue("value");
        showResolutions.setValue(value == null ? false : BooleanUtils.toBoolean(value));
    } else {
        SplitPanel split = getComponent("split");
        split.setSplitPosition(100);
        split.setLocked(true);
    }
}

From source file:com.haulmont.cuba.web.app.folders.CubaFoldersPane.java

protected void fillTree(Tree tree, List<? extends Folder> folders, Object rootItemId) {
    if (rootItemId != null) {
        tree.addItem(rootItemId);//ww w .ja v a 2s  .  c  o  m
    }
    for (Folder folder : folders) {
        tree.addItem(folder);
        setFolderTreeItemCaption(tree, folder);
        if (webConfig.getShowFolderIcons()) {
            if (folder instanceof SearchFolder) {
                if (BooleanUtils.isTrue(((SearchFolder) folder).getIsSet())) {
                    tree.setItemIcon(folder, WebComponentsHelper.getIcon("icons/set-small.png"));
                } else {
                    tree.setItemIcon(folder, WebComponentsHelper.getIcon("icons/search-folder-small.png"));
                }
            } else if (folder instanceof AppFolder) {
                tree.setItemIcon(folder, WebComponentsHelper.getIcon("icons/app-folder-small.png"));
            }
        }
    }
    for (Folder folder : folders) {
        if (folder.getParent() == null) {
            tree.setParent(folder, rootItemId);
        } else {
            if (tree.getItem(folder.getParent()) != null)
                tree.setParent(folder, folder.getParent());
            else
                tree.setParent(folder, rootItemId);
        }
    }
    for (Folder folder : folders) {
        if (!tree.hasChildren(folder)) {
            tree.setChildrenAllowed(folder, false);
        }
    }
}

From source file:jp.primecloud.auto.service.impl.ProcessServiceImpl.java

/**
 * {@inheritDoc}/*  ww w. j a  v a  2 s .c  o  m*/
 */
@Override
public void stopLoadBalancers(Long farmNo, List<Long> loadBalancerNos) {
    // ???
    List<LoadBalancer> loadBalancers = loadBalancerDao.readInLoadBalancerNos(loadBalancerNos);
    for (LoadBalancer loadBalancer : loadBalancers) {
        if (BooleanUtils.isTrue(loadBalancer.getEnabled())
                || BooleanUtils.isNotTrue(loadBalancer.getConfigure())) {
            loadBalancer.setEnabled(false);
            loadBalancer.setConfigure(true);
            loadBalancerDao.update(loadBalancer);
        }
    }

    // ??????????
    List<ComponentLoadBalancer> componentLoadBalancers = componentLoadBalancerDao
            .readInLoadBalancerNos(loadBalancerNos);
    if (!componentLoadBalancers.isEmpty()) {
        // ??????
        Set<Long> componentNos = new HashSet<Long>();
        for (ComponentLoadBalancer componentLoadBalancer : componentLoadBalancers) {
            componentNos.add(componentLoadBalancer.getComponentNo());
        }

        // ????
        List<ComponentInstance> componentInstances = componentInstanceDao.readInComponentNos(componentNos);
        for (ComponentInstance componentInstance : componentInstances) {
            if (BooleanUtils.isTrue(componentInstance.getEnabled())) {
                componentInstance.setEnabled(false);
                componentInstanceDao.update(componentInstance);
            }
        }

        // ??
        Set<Long> instanceNos = new HashSet<Long>();
        for (ComponentInstance componentInstance : componentInstances) {
            instanceNos.add(componentInstance.getInstanceNo());
        }
        List<Instance> instances = instanceDao.readInInstanceNos(instanceNos);
        for (Instance instance : instances) {
            if (BooleanUtils.isTrue(instance.getEnabled())) {
                instance.setEnabled(false);
                instanceDao.update(instance);
            }
        }
    }

    // ??
    List<LoadBalancerListener> listeners = loadBalancerListenerDao.readInLoadBalancerNos(loadBalancerNos);
    for (LoadBalancerListener listener : listeners) {
        if (BooleanUtils.isTrue(listener.getEnabled())) {
            listener.setEnabled(false);
            loadBalancerListenerDao.update(listener);
        }
    }

    // ????
    scheduleFarm(farmNo);
}