Search in sources :

Example 6 with AssetQuery

use of org.openremote.model.query.AssetQuery in project openremote by openremote.

the class AssetResourceImpl method createUserAssetLinks.

@Override
public void createUserAssetLinks(RequestParams requestParams, List<UserAssetLink> userAssetLinks) {
    // Restricted users cannot create or delete links
    if (isRestrictedUser()) {
        throw new WebApplicationException(FORBIDDEN);
    }
    // Check all links are for the same user and realm
    String realm = userAssetLinks.get(0).getId().getRealm();
    String userId = userAssetLinks.get(0).getId().getUserId();
    String[] assetIds = new String[userAssetLinks.size()];
    IntStream.range(0, userAssetLinks.size()).forEach(i -> {
        UserAssetLink userAssetLink = userAssetLinks.get(i);
        assetIds[i] = userAssetLink.getId().getAssetId();
        if (!userAssetLink.getId().getRealm().equals(realm) || !userAssetLink.getId().getUserId().equals(userId)) {
            throw new BadRequestException("All user asset links must be for the same user");
        }
    });
    if (!isSuperUser() && !realm.equals(getAuthenticatedRealm())) {
        throw new WebApplicationException(FORBIDDEN);
    }
    if (!identityService.getIdentityProvider().isUserInTenant(userId, realm)) {
        throw new WebApplicationException(FORBIDDEN);
    }
    List<Asset<?>> assets = assetStorageService.findAll(new AssetQuery().select(new AssetQuery.Select().excludeAttributes()).tenant(new TenantPredicate(realm)).ids(assetIds));
    if (assets.size() != userAssetLinks.size()) {
        throw new BadRequestException("One or more asset IDs are invalid");
    }
    try {
        assetStorageService.storeUserAssetLinks(userAssetLinks);
    } catch (Exception e) {
        throw new WebApplicationException(BAD_REQUEST);
    }
}
Also used : WebApplicationException(javax.ws.rs.WebApplicationException) AssetQuery(org.openremote.model.query.AssetQuery) BadRequestException(javax.ws.rs.BadRequestException) Asset(org.openremote.model.asset.Asset) TenantPredicate(org.openremote.model.query.filter.TenantPredicate) UserAssetLink(org.openremote.model.asset.UserAssetLink) BadRequestException(javax.ws.rs.BadRequestException) OptimisticLockException(javax.persistence.OptimisticLockException) ConstraintViolationException(javax.validation.ConstraintViolationException) WebApplicationException(javax.ws.rs.WebApplicationException)

Example 7 with AssetQuery

use of org.openremote.model.query.AssetQuery in project openremote by openremote.

the class AssetResourceImpl method getCurrentUserAssets.

@Override
public Asset<?>[] getCurrentUserAssets(RequestParams requestParams) {
    try {
        if (isSuperUser()) {
            return new Asset<?>[0];
        }
        AssetQuery assetQuery = new AssetQuery();
        if (!isRestrictedUser()) {
            assetQuery.tenant(new TenantPredicate(getAuthenticatedRealm())).recursive(true);
        } else {
            assetQuery.userIds(getUserId());
        }
        List<Asset<?>> assets = assetStorageService.findAll(assetQuery);
        // Compress response (the request attribute enables the interceptor)
        request.setAttribute(HttpHeaders.CONTENT_ENCODING, "gzip");
        return assets.toArray(new Asset[0]);
    } catch (IllegalStateException ex) {
        throw new WebApplicationException(ex, BAD_REQUEST);
    }
}
Also used : WebApplicationException(javax.ws.rs.WebApplicationException) AssetQuery(org.openremote.model.query.AssetQuery) Asset(org.openremote.model.asset.Asset) TenantPredicate(org.openremote.model.query.filter.TenantPredicate)

Example 8 with AssetQuery

use of org.openremote.model.query.AssetQuery in project openremote by openremote.

the class AssetDatapointService method purgeDataPoints.

protected void purgeDataPoints() {
    LOG.info("Starting data points purge daily task");
    try {
        // Get list of attributes that have custom durations
        List<Asset<?>> assets = assetStorageService.findAll(new AssetQuery().attributes(new AttributePredicate().meta(new NameValuePredicate(MetaItemType.DATA_POINTS_MAX_AGE_DAYS, null))));
        List<Pair<String, Attribute<?>>> attributes = assets.stream().map(asset -> asset.getAttributes().stream().filter(assetAttribute -> assetAttribute.hasMeta(MetaItemType.DATA_POINTS_MAX_AGE_DAYS)).map(assetAttribute -> new Pair<String, Attribute<?>>(asset.getId(), assetAttribute)).collect(toList())).flatMap(List::stream).collect(toList());
        // Purge data points not in the above list using default duration
        LOG.fine("Purging data points of attributes that use default max age days of " + maxDatapointAgeDays);
        persistenceService.doTransaction(em -> em.createQuery("delete from AssetDatapoint dp " + "where dp.timestamp < :dt" + buildWhereClause(attributes, true)).setParameter("dt", Date.from(timerService.getNow().truncatedTo(DAYS).minus(maxDatapointAgeDays, DAYS))).executeUpdate());
        if (!attributes.isEmpty()) {
            // Purge data points that have specific age constraints
            Map<Integer, List<Pair<String, Attribute<?>>>> ageAttributeRefMap = attributes.stream().collect(groupingBy(attributeRef -> attributeRef.value.getMetaValue(MetaItemType.DATA_POINTS_MAX_AGE_DAYS).orElse(maxDatapointAgeDays)));
            ageAttributeRefMap.forEach((age, attrs) -> {
                LOG.fine("Purging data points of " + attrs.size() + " attributes that use a max age of " + age);
                try {
                    persistenceService.doTransaction(em -> em.createQuery("delete from AssetDatapoint dp " + "where dp.timestamp < :dt" + buildWhereClause(attrs, false)).setParameter("dt", Date.from(timerService.getNow().truncatedTo(DAYS).minus(age, DAYS))).executeUpdate());
                } catch (Exception e) {
                    LOG.log(Level.SEVERE, "An error occurred whilst deleting data points, this should not happen", e);
                }
            });
        }
    } catch (Exception e) {
        LOG.log(Level.WARNING, "Failed to run data points purge", e);
    }
    LOG.info("Finished data points purge daily task");
}
Also used : AssetStorageService(org.openremote.manager.asset.AssetStorageService) Arrays(java.util.Arrays) ScheduledFuture(java.util.concurrent.ScheduledFuture) AssetProcessingException(org.openremote.manager.asset.AssetProcessingException) AttributeRef(org.openremote.model.attribute.AttributeRef) LocalDateTime(java.time.LocalDateTime) Collectors.groupingBy(java.util.stream.Collectors.groupingBy) AttributeWriteFailure(org.openremote.model.attribute.AttributeWriteFailure) STORE_DATA_POINTS(org.openremote.model.value.MetaItemType.STORE_DATA_POINTS) MapAccess.getInteger(org.openremote.container.util.MapAccess.getInteger) MapAccess.getString(org.openremote.container.util.MapAccess.getString) Level(java.util.logging.Level) UniqueIdentifierGenerator(org.openremote.container.util.UniqueIdentifierGenerator) Attribute(org.openremote.model.attribute.Attribute) Duration(java.time.Duration) Map(java.util.Map) NameValuePredicate(org.openremote.model.query.filter.NameValuePredicate) ManagerWebService(org.openremote.manager.web.ManagerWebService) Path(java.nio.file.Path) ManagerIdentityService(org.openremote.manager.security.ManagerIdentityService) Asset(org.openremote.model.asset.Asset) MetaItemType(org.openremote.model.value.MetaItemType) AssetQuery(org.openremote.model.query.AssetQuery) Pair(org.openremote.model.util.Pair) AssetDatapoint(org.openremote.model.datapoint.AssetDatapoint) AttributePredicate(org.openremote.model.query.filter.AttributePredicate) EntityManager(javax.persistence.EntityManager) Instant(java.time.Instant) Logger(java.util.logging.Logger) Collectors(java.util.stream.Collectors) File(java.io.File) ZoneId(java.time.ZoneId) Container(org.openremote.model.Container) Date(java.sql.Date) TimeUnit(java.util.concurrent.TimeUnit) DAYS(java.time.temporal.ChronoUnit.DAYS) List(java.util.List) Collectors.toList(java.util.stream.Collectors.toList) Paths(java.nio.file.Paths) TimerService(org.openremote.container.timer.TimerService) AssetUpdateProcessor(org.openremote.manager.asset.AssetUpdateProcessor) Source(org.openremote.model.attribute.AttributeEvent.Source) Attribute(org.openremote.model.attribute.Attribute) AssetQuery(org.openremote.model.query.AssetQuery) MapAccess.getString(org.openremote.container.util.MapAccess.getString) AttributePredicate(org.openremote.model.query.filter.AttributePredicate) AssetProcessingException(org.openremote.manager.asset.AssetProcessingException) MapAccess.getInteger(org.openremote.container.util.MapAccess.getInteger) Asset(org.openremote.model.asset.Asset) List(java.util.List) Collectors.toList(java.util.stream.Collectors.toList) NameValuePredicate(org.openremote.model.query.filter.NameValuePredicate) Pair(org.openremote.model.util.Pair)

Example 9 with AssetQuery

use of org.openremote.model.query.AssetQuery in project openremote by openremote.

the class EnergyOptimisationService method runOptimisation.

/**
 * Runs the optimisation routine for the specified time; it is important that this method does not throw an
 * exception as it will cancel the scheduled task thus stopping future optimisations.
 */
protected void runOptimisation(String optimisationAssetId, Instant optimisationTime) {
    OptimisationInstance optimisationInstance = assetOptimisationInstanceMap.get(optimisationAssetId);
    if (optimisationInstance == null) {
        return;
    }
    LOG.finer(getLogPrefix(optimisationAssetId) + "Running for time '" + formatter.format(optimisationTime));
    EnergyOptimiser optimiser = optimisationInstance.energyOptimiser;
    int intervalCount = optimiser.get24HourIntervalCount();
    double intervalSize = optimiser.getIntervalSize();
    LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching child assets of type '" + ElectricitySupplierAsset.class.getSimpleName() + "'");
    List<ElectricitySupplierAsset> supplierAssets = assetStorageService.findAll(new AssetQuery().types(ElectricitySupplierAsset.class).recursive(true).parents(optimisationAssetId)).stream().filter(asset -> asset.hasAttribute(ElectricitySupplierAsset.TARIFF_IMPORT)).map(asset -> (ElectricitySupplierAsset) asset).collect(Collectors.toList());
    if (supplierAssets.size() != 1) {
        LOG.warning(getLogPrefix(optimisationAssetId) + "Expected exactly one " + ElectricitySupplierAsset.class.getSimpleName() + " asset with a '" + ElectricitySupplierAsset.TARIFF_IMPORT.getName() + "' attribute but found: " + supplierAssets.size());
        return;
    }
    double[] powerNets = new double[intervalCount];
    ElectricitySupplierAsset supplierAsset = supplierAssets.get(0);
    if (LOG.isLoggable(Level.FINEST)) {
        LOG.finest(getLogPrefix(optimisationAssetId) + "Found child asset of type '" + ElectricitySupplierAsset.class.getSimpleName() + "': " + supplierAsset);
    }
    // Do some basic validation
    if (supplierAsset.getTariffImport().isPresent()) {
        LOG.warning(getLogPrefix(optimisationAssetId) + ElectricitySupplierAsset.class.getSimpleName() + " asset '" + ElectricitySupplierAsset.TARIFF_IMPORT.getName() + "' attribute has no value");
    }
    LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching optimisable child assets of type '" + ElectricityStorageAsset.class.getSimpleName() + "'");
    List<ElectricityStorageAsset> optimisableStorageAssets = assetStorageService.findAll(new AssetQuery().recursive(true).parents(optimisationAssetId).types(ElectricityStorageAsset.class).attributes(new LogicGroup<>(LogicGroup.Operator.AND, Collections.singletonList(new LogicGroup<>(LogicGroup.Operator.OR, new AttributePredicate(ElectricityStorageAsset.SUPPORTS_IMPORT.getName(), new BooleanPredicate(true)), new AttributePredicate(ElectricityStorageAsset.SUPPORTS_EXPORT.getName(), new BooleanPredicate(true)))), new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER_SETPOINT.getName()))))).stream().map(asset -> (ElectricityStorageAsset) asset).collect(Collectors.toList());
    List<ElectricityStorageAsset> finalOptimisableStorageAssets = optimisableStorageAssets;
    optimisableStorageAssets = optimisableStorageAssets.stream().filter(asset -> {
        // Exclude force charged assets (so we don't mess with the setpoint)
        if (forceChargeAssetIds.contains(asset.getId())) {
            LOG.finest("Optimisable asset was requested to force charge so it won't be optimised: " + asset.getId());
            @SuppressWarnings("OptionalGetWithoutIsPresent") Attribute<Double> powerAttribute = asset.getAttribute(ElectricityAsset.POWER).get();
            double[] powerLevels = get24HAttributeValues(asset.getId(), powerAttribute, optimiser.getIntervalSize(), intervalCount, optimisationTime);
            IntStream.range(0, intervalCount).forEach(i -> powerNets[i] += powerLevels[i]);
            double currentEnergyLevel = asset.getEnergyLevel().orElse(0d);
            double maxEnergyLevel = getElectricityStorageAssetEnergyLevelMax(asset);
            if (currentEnergyLevel >= maxEnergyLevel) {
                LOG.info("Force charged asset has reached maxEnergyLevelPercentage so stopping charging: " + asset.getId());
                forceChargeAssetIds.remove(asset.getId());
                assetProcessingService.sendAttributeEvent(new AttributeEvent(asset.getId(), ElectricityStorageAsset.POWER_SETPOINT, 0d));
                assetProcessingService.sendAttributeEvent(new AttributeEvent(asset.getId(), ElectricityStorageAsset.FORCE_CHARGE, AttributeExecuteStatus.COMPLETED));
            }
            return false;
        }
        if (asset instanceof ElectricityChargerAsset) {
            // Check if it has a child vehicle asset
            return finalOptimisableStorageAssets.stream().noneMatch(a -> {
                if (a instanceof ElectricVehicleAsset && a.getParentId().equals(asset.getId())) {
                    // Take the lowest power max from vehicle or charger
                    double vehiclePowerImportMax = a.getPowerImportMax().orElse(Double.MAX_VALUE);
                    double vehiclePowerExportMax = a.getPowerExportMax().orElse(Double.MAX_VALUE);
                    double chargerPowerImportMax = asset.getPowerImportMax().orElse(Double.MAX_VALUE);
                    double chargerPowerExportMax = asset.getPowerExportMax().orElse(Double.MAX_VALUE);
                    double smallestPowerImportMax = Math.min(vehiclePowerImportMax, chargerPowerImportMax);
                    double smallestPowerExportMax = Math.min(vehiclePowerExportMax, chargerPowerExportMax);
                    if (smallestPowerImportMax < vehiclePowerImportMax) {
                        LOG.fine("Reducing vehicle power import max due to connected charger limit: vehicle=" + a.getId() + ", oldPowerImportMax=" + vehiclePowerImportMax + ", newPowerImportMax=" + smallestPowerImportMax);
                        a.setPowerImportMax(smallestPowerImportMax);
                    }
                    if (smallestPowerExportMax < vehiclePowerExportMax) {
                        LOG.fine("Reducing vehicle power Export max due to connected charger limit: vehicle=" + a.getId() + ", oldPowerExportMax=" + vehiclePowerExportMax + ", newPowerExportMax=" + smallestPowerExportMax);
                        a.setPowerExportMax(smallestPowerExportMax);
                    }
                    LOG.finest("Excluding charger from optimisable assets and child vehicle will be used instead: " + asset.getId());
                    return true;
                }
                return false;
            });
        }
        return true;
    }).sorted(Comparator.comparingInt(asset -> asset.getEnergyLevelSchedule().map(schedule -> 0).orElse(1))).collect(Collectors.toList());
    if (optimisableStorageAssets.isEmpty()) {
        LOG.warning(getLogPrefix(optimisationAssetId) + "Expected at least one optimisable '" + ElectricityStorageAsset.class.getSimpleName() + " asset with a '" + ElectricityAsset.POWER_SETPOINT.getName() + "' attribute but found none");
        return;
    }
    if (LOG.isLoggable(Level.FINEST)) {
        LOG.finest(getLogPrefix(optimisationAssetId) + "Found optimisable child assets of type '" + ElectricityStorageAsset.class.getSimpleName() + "': " + optimisableStorageAssets.stream().map(Asset::getId).collect(Collectors.joining(", ")));
    }
    LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching plain consumer and producer child assets of type '" + ElectricityProducerAsset.class.getSimpleName() + "', '" + ElectricityConsumerAsset.class.getSimpleName() + "', '" + ElectricityStorageAsset.class.getSimpleName() + "'");
    AtomicInteger count = new AtomicInteger(0);
    assetStorageService.findAll(new AssetQuery().recursive(true).parents(optimisationAssetId).types(ElectricityConsumerAsset.class, ElectricityProducerAsset.class).attributes(new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER.getName())))).forEach(asset -> {
        @SuppressWarnings("OptionalGetWithoutIsPresent") Attribute<Double> powerAttribute = asset.getAttribute(ElectricityAsset.POWER).get();
        double[] powerLevels = get24HAttributeValues(asset.getId(), powerAttribute, optimiser.getIntervalSize(), intervalCount, optimisationTime);
        IntStream.range(0, intervalCount).forEach(i -> powerNets[i] += powerLevels[i]);
        count.incrementAndGet();
    });
    // Get power of storage assets that don't support neither import or export (treat them as plain consumers/producers)
    List<ElectricityStorageAsset> plainStorageAssets = assetStorageService.findAll(new AssetQuery().recursive(true).parents(optimisationAssetId).types(ElectricityStorageAsset.class).attributes(new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER.getName())), new AttributePredicate(ElectricityStorageAsset.SUPPORTS_IMPORT.getName(), new BooleanPredicate(true), true, null), new AttributePredicate(ElectricityStorageAsset.SUPPORTS_EXPORT.getName(), new BooleanPredicate(true), true, null))).stream().map(asset -> (ElectricityStorageAsset) asset).collect(Collectors.toList());
    // Exclude chargers with a power value != 0 and a child vehicle with a power value != 0 (avoid double counting - vehicle takes priority)
    plainStorageAssets.stream().filter(asset -> {
        if (asset instanceof ElectricityChargerAsset) {
            // Check if it has a child vehicle asset also check optimisable assets as child vehicle could be in there
            return plainStorageAssets.stream().noneMatch(a -> {
                if (a instanceof ElectricVehicleAsset && a.getParentId().equals(asset.getId())) {
                    LOG.finest("Excluding charger from plain consumer/producer calculations to avoid double counting power: " + asset.getId());
                    return true;
                }
                return false;
            }) && finalOptimisableStorageAssets.stream().noneMatch(a -> {
                if (a instanceof ElectricVehicleAsset && a.getParentId().equals(asset.getId())) {
                    LOG.finest("Excluding charger from plain consumer/producer calculations to avoid double counting power: " + asset.getId());
                    return true;
                }
                return false;
            });
        }
        return true;
    }).forEach(asset -> {
        @SuppressWarnings("OptionalGetWithoutIsPresent") Attribute<Double> powerAttribute = asset.getAttribute(ElectricityAsset.POWER).get();
        double[] powerLevels = get24HAttributeValues(asset.getId(), powerAttribute, optimiser.getIntervalSize(), intervalCount, optimisationTime);
        IntStream.range(0, intervalCount).forEach(i -> powerNets[i] += powerLevels[i]);
        count.incrementAndGet();
    });
    if (LOG.isLoggable(Level.FINER)) {
        LOG.finer(getLogPrefix(optimisationAssetId) + "Found plain consumer and producer child assets count=" + count.get());
        LOG.finer("Calculated net power of consumers and producers: " + Arrays.toString(powerNets));
    }
    // Get supplier costs for each interval
    double financialWeightingImport = optimiser.getFinancialWeighting();
    double financialWeightingExport = optimiser.getFinancialWeighting();
    if (financialWeightingImport < 1d && !supplierAsset.getCarbonImport().isPresent()) {
        financialWeightingImport = 1d;
    }
    if (financialWeightingExport < 1d && !supplierAsset.getCarbonExport().isPresent()) {
        financialWeightingExport = 1d;
    }
    double[] costsImport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.TARIFF_IMPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
    double[] costsExport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.TARIFF_EXPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
    if (financialWeightingImport < 1d || financialWeightingExport < 1d) {
        double[] carbonImport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.CARBON_IMPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
        double[] carbonExport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.CARBON_EXPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
        LOG.finer(getLogPrefix(optimisationAssetId) + "Adjusting costs to include some carbon weighting, financialWeightingImport=" + financialWeightingImport + ", financialWeightingExport=" + financialWeightingExport);
        for (int i = 0; i < costsImport.length; i++) {
            costsImport[i] = (financialWeightingImport * costsImport[i]) + ((1 - financialWeightingImport) * carbonImport[i]);
            costsExport[i] = (financialWeightingExport * costsExport[i]) + ((1 - financialWeightingExport) * carbonExport[i]);
        }
    }
    if (LOG.isLoggable(Level.FINER)) {
        LOG.finer(getLogPrefix(optimisationAssetId) + "Import costs: " + Arrays.toString(costsImport));
        LOG.finer(getLogPrefix(optimisationAssetId) + "Export costs: " + Arrays.toString(costsExport));
    }
    // Savings variables
    List<String> obsoleteUnoptimisedAssetIds = new ArrayList<>(optimisationInstance.unoptimisedStorageAssetEnergyLevels.keySet());
    double unoptimisedPower = powerNets[0];
    double financialCost = 0d;
    double carbonCost = 0d;
    double unoptimisedFinancialCost = 0d;
    double unoptimisedCarbonCost = 0d;
    // Optimise storage assets with priority on storage assets with an energy schedule (already sorted above)
    double importPowerMax = supplierAsset.getPowerImportMax().orElse(Double.MAX_VALUE);
    double exportPowerMax = -1 * supplierAsset.getPowerExportMax().orElse(Double.MAX_VALUE);
    double[] importPowerMaxes = new double[intervalCount];
    double[] exportPowerMaxes = new double[intervalCount];
    Arrays.fill(importPowerMaxes, importPowerMax);
    Arrays.fill(exportPowerMaxes, exportPowerMax);
    long periodSeconds = (long) (optimiser.getIntervalSize() * 60 * 60);
    for (ElectricityStorageAsset storageAsset : optimisableStorageAssets) {
        boolean hasSetpoint = storageAsset.hasAttribute(ElectricityStorageAsset.POWER_SETPOINT);
        boolean supportsExport = storageAsset.isSupportsExport().orElse(false);
        boolean supportsImport = storageAsset.isSupportsImport().orElse(false);
        LOG.finer(getLogPrefix(optimisationAssetId) + "Optimising power set points for storage asset: " + storageAsset);
        if (!supportsExport && !supportsImport) {
            LOG.finest(getLogPrefix(optimisationAssetId) + "Storage asset doesn't support import or export: " + storageAsset.getId());
            continue;
        }
        if (!hasSetpoint) {
            LOG.info(getLogPrefix(optimisationAssetId) + "Storage asset has no '" + ElectricityStorageAsset.POWER_SETPOINT.getName() + "' attribute so cannot be controlled: " + storageAsset.getId());
            continue;
        }
        double energyCapacity = storageAsset.getEnergyCapacity().orElse(0d);
        double energyLevel = Math.min(energyCapacity, storageAsset.getEnergyLevel().orElse(-1d));
        if (energyCapacity <= 0d || energyLevel < 0) {
            LOG.info(getLogPrefix(optimisationAssetId) + "Storage asset has no capacity or energy level so cannot import or export energy: " + storageAsset.getId());
            continue;
        }
        double energyLevelMax = Math.min(energyCapacity, ((double) storageAsset.getEnergyLevelPercentageMax().orElse(100) / 100) * energyCapacity);
        double energyLevelMin = Math.min(energyCapacity, ((double) storageAsset.getEnergyLevelPercentageMin().orElse(0) / 100) * energyCapacity);
        double[] energyLevelMins = new double[intervalCount];
        double[] energyLevelMaxs = new double[intervalCount];
        Arrays.fill(energyLevelMins, energyLevelMin);
        Arrays.fill(energyLevelMaxs, energyLevelMax);
        // Does the storage support import and have an energy level schedule
        Optional<Integer[][]> energyLevelScheduleOptional = storageAsset.getEnergyLevelSchedule();
        boolean hasEnergyMinRequirement = energyLevelMin > 0 || energyLevelScheduleOptional.isPresent();
        double powerExportMax = storageAsset.getPowerExportMax().map(power -> -1 * power).orElse(Double.MIN_VALUE);
        double powerImportMax = storageAsset.getPowerImportMax().orElse(Double.MAX_VALUE);
        int[][] energySchedule = energyLevelScheduleOptional.map(dayArr -> Arrays.stream(dayArr).map(hourArr -> Arrays.stream(hourArr).mapToInt(i -> i != null ? i : 0).toArray()).toArray(int[][]::new)).orElse(null);
        if (energySchedule != null) {
            LOG.finer(getLogPrefix(optimisationAssetId) + "Applying energy schedule for storage asset: " + storageAsset.getId());
            optimiser.applyEnergySchedule(energyLevelMins, energyLevelMaxs, energyCapacity, energySchedule, LocalDateTime.ofInstant(Instant.ofEpochMilli(timerService.getCurrentTimeMillis()), ZoneId.systemDefault()));
        }
        double maxEnergyLevelMin = Arrays.stream(energyLevelMins).max().orElse(0);
        boolean isConnected = storageAssetConnected(storageAsset);
        // TODO: Make these a function of energy level
        Function<Integer, Double> powerImportMaxCalculator = interval -> interval == 0 && !isConnected ? 0 : powerImportMax;
        Function<Integer, Double> powerExportMaxCalculator = interval -> interval == 0 && !isConnected ? 0 : powerExportMax;
        if (hasEnergyMinRequirement) {
            LOG.finer(getLogPrefix(optimisationAssetId) + "Normalising min energy requirements for storage asset: " + storageAsset.getId());
            optimiser.normaliseEnergyMinRequirements(energyLevelMins, powerImportMaxCalculator, powerExportMaxCalculator, energyLevel);
            if (LOG.isLoggable(Level.FINEST)) {
                LOG.finest(getLogPrefix(optimisationAssetId) + "Min energy requirements for storage asset '" + storageAsset.getId() + "': " + Arrays.toString(energyLevelMins));
            }
        }
        // Calculate the power setpoints for this asset and update power net values for each interval
        double[] setpoints = getStoragePowerSetpoints(optimisationInstance, storageAsset, energyLevelMins, energyLevelMaxs, powerNets, importPowerMaxes, exportPowerMaxes, costsImport, costsExport);
        if (setpoints != null) {
            // Assume these setpoints will be applied so update the power net values with these
            for (int i = 0; i < powerNets.length; i++) {
                if (i == 0) {
                    if (!storageAssetConnected(storageAsset)) {
                        LOG.finer("Optimised storage asset not connected so interval 0 will not be counted or actioned: " + storageAsset.getId());
                        setpoints[i] = 0;
                        continue;
                    }
                    // Update savings/cost data with costs specific to this asset
                    if (setpoints[i] > 0) {
                        financialCost += storageAsset.getTariffImport().orElse(0d) * setpoints[i] * intervalSize;
                    } else {
                        financialCost += storageAsset.getTariffExport().orElse(0d) * -1 * setpoints[i] * intervalSize;
                    }
                }
                powerNets[i] += setpoints[i];
            }
            // Push the setpoints into the prediction service for the storage asset's setpoint attribute and set current setpoint
            List<Pair<?, LocalDateTime>> valuesAndTimestamps = IntStream.range(1, setpoints.length).mapToObj(i -> new Pair<>(setpoints[i], LocalDateTime.ofInstant(optimisationTime.plus(periodSeconds * i, ChronoUnit.SECONDS), ZoneId.systemDefault()))).collect(Collectors.toList());
            assetPredictedDatapointService.updateValues(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT.getName(), valuesAndTimestamps);
        }
        assetProcessingService.sendAttributeEvent(new AttributeEvent(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT, setpoints != null ? setpoints[0] : null));
        // Update unoptimised power for this asset
        obsoleteUnoptimisedAssetIds.remove(storageAsset.getId());
        double assetUnoptimisedPower = getStorageUnoptimisedImportPower(optimisationInstance, optimisationAssetId, storageAsset, maxEnergyLevelMin, Math.max(0, powerImportMax - unoptimisedPower));
        unoptimisedPower += assetUnoptimisedPower;
        unoptimisedFinancialCost += storageAsset.getTariffImport().orElse(0d) * assetUnoptimisedPower * intervalSize;
    }
    // Clear out un-optimised data for not found assets
    obsoleteUnoptimisedAssetIds.forEach(optimisationInstance.unoptimisedStorageAssetEnergyLevels.keySet()::remove);
    // Calculate and store savings data
    carbonCost = (powerNets[0] >= 0 ? supplierAsset.getCarbonImport().orElse(0d) : -1 * supplierAsset.getCarbonExport().orElse(0d)) * powerNets[0] * intervalSize;
    financialCost += (powerNets[0] >= 0 ? supplierAsset.getTariffImport().orElse(0d) : -1 * supplierAsset.getTariffExport().orElse(0d)) * powerNets[0] * intervalSize;
    unoptimisedCarbonCost = (unoptimisedPower >= 0 ? supplierAsset.getCarbonImport().orElse(0d) : -1 * supplierAsset.getCarbonExport().orElse(0d)) * unoptimisedPower * intervalSize;
    unoptimisedFinancialCost += (unoptimisedPower >= 0 ? supplierAsset.getTariffImport().orElse(0d) : -1 * supplierAsset.getTariffExport().orElse(0d)) * unoptimisedPower * intervalSize;
    double financialSaving = unoptimisedFinancialCost - financialCost;
    double carbonSaving = unoptimisedCarbonCost - carbonCost;
    LOG.info(getLogPrefix(optimisationAssetId) + "Current interval financial saving = " + financialSaving);
    LOG.info(getLogPrefix(optimisationAssetId) + "Current interval carbon saving = " + carbonSaving);
    financialSaving += optimisationInstance.optimisationAsset.getFinancialSaving().orElse(0d);
    carbonSaving += optimisationInstance.optimisationAsset.getCarbonSaving().orElse(0d);
    // Update in memory asset
    optimisationInstance.optimisationAsset.setFinancialSaving(financialSaving);
    optimisationInstance.optimisationAsset.setCarbonSaving(carbonSaving);
    // Push new values into the DB
    assetProcessingService.sendAttributeEvent(new AttributeEvent(optimisationAssetId, EnergyOptimisationAsset.FINANCIAL_SAVING, financialSaving));
    assetProcessingService.sendAttributeEvent(new AttributeEvent(optimisationAssetId, EnergyOptimisationAsset.CARBON_SAVING, carbonSaving));
}
Also used : AssetStorageService(org.openremote.manager.asset.AssetStorageService) IntStream(java.util.stream.IntStream) GatewayService.isNotForGateway(org.openremote.manager.gateway.GatewayService.isNotForGateway) java.util(java.util) DatapointInterval(org.openremote.model.datapoint.DatapointInterval) ScheduledFuture(java.util.concurrent.ScheduledFuture) AssetDescriptor(org.openremote.model.asset.AssetDescriptor) BiFunction(java.util.function.BiFunction) AttributeRef(org.openremote.model.attribute.AttributeRef) AssetProcessingService(org.openremote.manager.asset.AssetProcessingService) ValueUtil(org.openremote.model.util.ValueUtil) Function(java.util.function.Function) Level(java.util.logging.Level) java.time(java.time) BooleanPredicate(org.openremote.model.query.filter.BooleanPredicate) Attribute(org.openremote.model.attribute.Attribute) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) AttributeEvent(org.openremote.model.attribute.AttributeEvent) org.openremote.model.asset.impl(org.openremote.model.asset.impl) ScheduledExecutorService(java.util.concurrent.ScheduledExecutorService) PersistenceEvent(org.openremote.model.PersistenceEvent) LogicGroup(org.openremote.model.query.LogicGroup) MessageBrokerService(org.openremote.container.message.MessageBrokerService) AssetPredictedDatapointService(org.openremote.manager.datapoint.AssetPredictedDatapointService) Asset(org.openremote.model.asset.Asset) MetaItemType(org.openremote.model.value.MetaItemType) HOURS(java.time.temporal.ChronoUnit.HOURS) AssetQuery(org.openremote.model.query.AssetQuery) Pair(org.openremote.model.util.Pair) ContainerService(org.openremote.model.ContainerService) AttributePredicate(org.openremote.model.query.filter.AttributePredicate) Logger(java.util.logging.Logger) Collectors(java.util.stream.Collectors) Container(org.openremote.model.Container) ValueDatapoint(org.openremote.model.datapoint.ValueDatapoint) TimeUnit(java.util.concurrent.TimeUnit) ClientEventService(org.openremote.manager.event.ClientEventService) ChronoUnit(java.time.temporal.ChronoUnit) StringPredicate(org.openremote.model.query.filter.StringPredicate) RouteBuilder(org.apache.camel.builder.RouteBuilder) TimerService(org.openremote.container.timer.TimerService) PERSISTENCE_TOPIC(org.openremote.container.persistence.PersistenceService.PERSISTENCE_TOPIC) DateTimeFormatter(java.time.format.DateTimeFormatter) PersistenceService.isPersistenceEventForEntityType(org.openremote.container.persistence.PersistenceService.isPersistenceEventForEntityType) GatewayService(org.openremote.manager.gateway.GatewayService) AttributeExecuteStatus(org.openremote.model.attribute.AttributeExecuteStatus) StringPredicate(org.openremote.model.query.filter.StringPredicate) Attribute(org.openremote.model.attribute.Attribute) AttributePredicate(org.openremote.model.query.filter.AttributePredicate) AttributeEvent(org.openremote.model.attribute.AttributeEvent) BooleanPredicate(org.openremote.model.query.filter.BooleanPredicate) Pair(org.openremote.model.util.Pair) AssetQuery(org.openremote.model.query.AssetQuery) ValueDatapoint(org.openremote.model.datapoint.ValueDatapoint) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) AtomicInteger(java.util.concurrent.atomic.AtomicInteger)

Example 10 with AssetQuery

use of org.openremote.model.query.AssetQuery in project openremote by openremote.

the class PushNotificationHandler method getTargets.

@Override
public List<Notification.Target> getTargets(Notification.Source source, String sourceId, List<Notification.Target> targets, AbstractNotificationMessage message) {
    // Check if message is going to a topic if so then filter consoles subscribed to that topic
    PushNotificationMessage pushMessage = (PushNotificationMessage) message;
    List<Notification.Target> mappedTargets = new ArrayList<>();
    if (pushMessage.getTargetType() == TOPIC || pushMessage.getTargetType() == CONDITION) {
        mappedTargets.add(new Notification.Target(Notification.TargetType.CUSTOM, pushMessage.getTargetType() + ": " + pushMessage.getTarget()));
        return mappedTargets;
    }
    if (targets != null) {
        targets.forEach(target -> {
            Notification.TargetType targetType = target.getType();
            String targetId = target.getId();
            switch(targetType) {
                case TENANT:
                    // Get all console assets with a push provider defined within the specified tenant
                    List<Asset<?>> consoleAssets = assetStorageService.findAll(new AssetQuery().select(new AssetQuery.Select().excludeAttributes()).tenant(new TenantPredicate(targetId)).types(ConsoleAsset.class).attributes(new AttributePredicate(ConsoleAsset.CONSOLE_PROVIDERS, null, false, new NameValuePredicate.Path(PushNotificationMessage.TYPE))));
                    // Get all user ids which have pushNotificationsDisabled set to false
                    String[] userIds = Arrays.stream(managerIdentityService.getIdentityProvider().queryUsers(new UserQuery().tenant(new TenantPredicate((targetId))))).filter(user -> Boolean.parseBoolean(user.getAttributes().getOrDefault(KEYCLOAK_USER_ATTRIBUTE_PUSH_NOTIFICATIONS_DISABLED, Collections.singletonList("false")).get(0))).map(User::getId).toArray(String[]::new);
                    String[] assetIds = assetStorageService.findUserAssetLinks(targetId, null, null).stream().filter(userAssetLink -> Arrays.stream(userIds).anyMatch(userId -> userId.equals(userAssetLink.getId().getUserId()))).map(userAssetLink -> userAssetLink.getId().getAssetId()).toArray(String[]::new);
                    // Remove consoleAssets which are linked to an User which has pushNotificationsDisabled set to false
                    consoleAssets = consoleAssets.stream().filter(consoleAsset -> Arrays.stream(assetIds).noneMatch(assetId -> assetId.equals(consoleAsset.getId()))).collect(Collectors.toList());
                    mappedTargets.addAll(consoleAssets.stream().map(asset -> new Notification.Target(Notification.TargetType.ASSET, asset.getId())).collect(Collectors.toList()));
                    break;
                case USER:
                    Optional<User> user = Arrays.stream(managerIdentityService.getIdentityProvider().queryUsers(new UserQuery().ids(targetId))).findFirst();
                    if (user.isPresent() && !Boolean.parseBoolean(user.get().getAttributes().getOrDefault(KEYCLOAK_USER_ATTRIBUTE_PUSH_NOTIFICATIONS_DISABLED, Collections.singletonList("false")).get(0))) {
                        // Get all console assets linked to the specified user
                        String[] ids = assetStorageService.findUserAssetLinks(null, targetId, null).stream().map(userAssetLink -> userAssetLink.getId().getAssetId()).toArray(String[]::new);
                        if (ids.length > 0) {
                            mappedTargets.addAll(assetStorageService.findAll(new AssetQuery().select(new AssetQuery.Select().excludeAttributes()).ids(ids).types(ConsoleAsset.class).attributes(new AttributePredicate(ConsoleAsset.CONSOLE_PROVIDERS, null, false, new NameValuePredicate.Path(PushNotificationMessage.TYPE)))).stream().map(asset -> new Notification.Target(Notification.TargetType.ASSET, asset.getId())).collect(Collectors.toList()));
                        }
                    } else {
                        LOG.fine("No console assets linked to target user");
                        return;
                    }
                    break;
                case ASSET:
                    // Find all console descendants of the specified asset
                    consoleAssets = assetStorageService.findAll(new AssetQuery().select(new AssetQuery.Select().excludeAttributes()).paths(new PathPredicate(targetId)).types(ConsoleAsset.class).attributes(new AttributePredicate(ConsoleAsset.CONSOLE_PROVIDERS, null, false, new NameValuePredicate.Path(PushNotificationMessage.TYPE))));
                    UserAssetLink[] userAssetLinks = consoleAssets.stream().map(consoleAsset -> assetStorageService.findUserAssetLinks(null, null, consoleAsset.getId())).flatMap(Collection::stream).toArray(UserAssetLink[]::new);
                    // Get all user ids which have pushNotificationsDisabled set to false
                    assetIds = Arrays.stream(userAssetLinks).filter(userAssetLink -> Arrays.stream(managerIdentityService.getIdentityProvider().queryUsers(new UserQuery().asset(new UserAssetPredicate(userAssetLink.getId().getAssetId())))).filter(user1 -> Boolean.parseBoolean(user1.getAttributes().getOrDefault(KEYCLOAK_USER_ATTRIBUTE_PUSH_NOTIFICATIONS_DISABLED, Collections.singletonList("false")).get(0))).map(User::getId).anyMatch(userId -> userId.equals(userAssetLink.getId().getUserId()))).map(userAssetLink -> userAssetLink.getId().getAssetId()).toArray(String[]::new);
                    // Remove consoleAssets which are linked to an User which has pushNotificationsDisabled set to false
                    consoleAssets = consoleAssets.stream().filter(consoleAsset -> Arrays.stream(assetIds).noneMatch(assetId -> assetId.equals(consoleAsset.getId()))).collect(Collectors.toList());
                    mappedTargets.addAll(consoleAssets.stream().map(asset -> new Notification.Target(Notification.TargetType.ASSET, asset.getId())).collect(Collectors.toList()));
                    break;
            }
        });
    }
    return mappedTargets;
}
Also used : AssetStorageService(org.openremote.manager.asset.AssetStorageService) GatewayService.isNotForGateway(org.openremote.manager.gateway.GatewayService.isNotForGateway) UserAssetLink(org.openremote.model.asset.UserAssetLink) java.util(java.util) com.google.firebase.messaging(com.google.firebase.messaging) AbstractNotificationMessage(org.openremote.model.notification.AbstractNotificationMessage) FirebaseOptions(com.google.firebase.FirebaseOptions) ValueUtil(org.openremote.model.util.ValueUtil) Level(java.util.logging.Level) Notification(org.openremote.model.notification.Notification) UserQuery(org.openremote.model.query.UserQuery) PersistenceService(org.openremote.container.persistence.PersistenceService) ConsoleProvider(org.openremote.model.console.ConsoleProvider) org.openremote.model.query.filter(org.openremote.model.query.filter) StreamSupport(java.util.stream.StreamSupport) TextUtil(org.openremote.model.util.TextUtil) TypeReference(com.fasterxml.jackson.core.type.TypeReference) NotificationSendResult(org.openremote.model.notification.NotificationSendResult) PersistenceEvent(org.openremote.model.PersistenceEvent) MessageBrokerService(org.openremote.container.message.MessageBrokerService) User(org.openremote.model.security.User) TargetType(org.openremote.model.notification.PushNotificationMessage.TargetType) ManagerIdentityService(org.openremote.manager.security.ManagerIdentityService) Asset(org.openremote.model.asset.Asset) Files(java.nio.file.Files) GoogleCredentials(com.google.auth.oauth2.GoogleCredentials) KEYCLOAK_USER_ATTRIBUTE_PUSH_NOTIFICATIONS_DISABLED(org.openremote.manager.security.ManagerKeycloakIdentityProvider.KEYCLOAK_USER_ATTRIBUTE_PUSH_NOTIFICATIONS_DISABLED) AssetQuery(org.openremote.model.query.AssetQuery) JsonProcessingException(com.fasterxml.jackson.core.JsonProcessingException) ContainerService(org.openremote.model.ContainerService) Logger(java.util.logging.Logger) Collectors(java.util.stream.Collectors) Container(org.openremote.model.Container) PushNotificationMessage(org.openremote.model.notification.PushNotificationMessage) RouteBuilder(org.apache.camel.builder.RouteBuilder) ConsoleAsset(org.openremote.model.asset.impl.ConsoleAsset) Paths(java.nio.file.Paths) GatewayService(org.openremote.manager.gateway.GatewayService) FirebaseApp(com.google.firebase.FirebaseApp) InputStream(java.io.InputStream) GlobalLock.withLock(org.openremote.container.concurrent.GlobalLock.withLock) User(org.openremote.model.security.User) Notification(org.openremote.model.notification.Notification) UserAssetLink(org.openremote.model.asset.UserAssetLink) Asset(org.openremote.model.asset.Asset) ConsoleAsset(org.openremote.model.asset.impl.ConsoleAsset) ConsoleAsset(org.openremote.model.asset.impl.ConsoleAsset) AssetQuery(org.openremote.model.query.AssetQuery) UserQuery(org.openremote.model.query.UserQuery) PushNotificationMessage(org.openremote.model.notification.PushNotificationMessage)

Aggregations

AssetQuery (org.openremote.model.query.AssetQuery)17 Asset (org.openremote.model.asset.Asset)9 Level (java.util.logging.Level)8 Logger (java.util.logging.Logger)8 Collectors (java.util.stream.Collectors)8 ManagerIdentityService (org.openremote.manager.security.ManagerIdentityService)7 java.util (java.util)6 RouteBuilder (org.apache.camel.builder.RouteBuilder)6 MessageBrokerService (org.openremote.container.message.MessageBrokerService)6 AssetStorageService (org.openremote.manager.asset.AssetStorageService)6 Container (org.openremote.model.Container)6 TextUtil (org.openremote.model.util.TextUtil)6 EntityManager (javax.persistence.EntityManager)5 PERSISTENCE_TOPIC (org.openremote.container.persistence.PersistenceService.PERSISTENCE_TOPIC)5 PersistenceService.isPersistenceEventForEntityType (org.openremote.container.persistence.PersistenceService.isPersistenceEventForEntityType)5 TimerService (org.openremote.container.timer.TimerService)5 ClientEventService (org.openremote.manager.event.ClientEventService)5 GatewayService (org.openremote.manager.gateway.GatewayService)5 ContainerService (org.openremote.model.ContainerService)5 AttributeEvent (org.openremote.model.attribute.AttributeEvent)5