Examples with Asset org.openremote.model.asset.Asset used on opensource projects

Example 36 with Asset

use of org.openremote.model.asset.Asset in project openremote by openremote.

the class RulesetResourceImpl method createAssetRuleset.

/* ################################################################################################# */
@Override
public void createAssetRuleset(@BeanParam RequestParams requestParams, AssetRuleset ruleset) {
    String assetId = ruleset.getAssetId();
    if (assetId == null || assetId.length() == 0) {
        throw new WebApplicationException("Missing asset identifier value", BAD_REQUEST);
    }
    Asset asset = assetStorageService.find(assetId, false);
    if (asset == null) {
        throw new WebApplicationException(NOT_FOUND);
    }
    if (!isRealmAccessibleByUser(asset.getTenantRealm())) {
        throw new WebApplicationException(Response.Status.FORBIDDEN);
    }
    if (isRestrictedUser() && !assetStorageService.isUserAsset(getUserId(), asset.getId())) {
        throw new WebApplicationException(Response.Status.FORBIDDEN);
    }
    rulesetStorageService.merge(ruleset);
}

Example 37 with Asset

use of org.openremote.model.asset.Asset in project openremote by openremote.

the class RulesetResourceImpl method updateAssetRuleset.

@Override
public void updateAssetRuleset(@BeanParam RequestParams requestParams, Long id, AssetRuleset ruleset) {
    AssetRuleset existingRuleset = rulesetStorageService.findById(AssetRuleset.class, id);
    if (existingRuleset == null) {
        throw new WebApplicationException(NOT_FOUND);
    }
    Asset asset = assetStorageService.find(existingRuleset.getAssetId(), false);
    if (asset == null) {
        throw new WebApplicationException(NOT_FOUND);
    }
    if (!isRealmAccessibleByUser(asset.getTenantRealm())) {
        throw new WebApplicationException(Response.Status.FORBIDDEN);
    }
    if (isRestrictedUser() && !assetStorageService.isUserAsset(getUserId(), asset.getId())) {
        throw new WebApplicationException(Response.Status.FORBIDDEN);
    }
    if (!id.equals(ruleset.getId())) {
        throw new WebApplicationException("Requested ID and ruleset ID don't match", BAD_REQUEST);
    }
    if (!existingRuleset.getAssetId().equals(ruleset.getAssetId())) {
        throw new WebApplicationException("Can't update asset ID, delete and create the ruleset to reassign", BAD_REQUEST);
    }
    rulesetStorageService.merge(ruleset);
}

Example 38 with Asset

use of org.openremote.model.asset.Asset in project openremote by openremote.

the class AssetsFacade method query.

@Override
public Assets.RestrictedQuery query() {
    Assets.RestrictedQuery query = new Assets.RestrictedQuery() {

        @Override
        public Assets.RestrictedQuery select(Select select) {
            throw new IllegalArgumentException("Overriding query projection is not allowed in this rules scope");
        }

        @Override
        public Assets.RestrictedQuery id(String id) {
            throw new IllegalArgumentException("Overriding query restriction is not allowed in this rules scope");
        }

        @Override
        public Assets.RestrictedQuery tenant(TenantPredicate tenantPredicate) {
            if (GlobalRuleset.class.isAssignableFrom(rulesEngineId.getScope()))
                return super.tenant(tenantPredicate);
            throw new IllegalArgumentException("Overriding query restriction is not allowed in this rules scope");
        }

        @Override
        public Assets.RestrictedQuery userId(String userId) {
            throw new IllegalArgumentException("Overriding query restriction is not allowed in this rules scope");
        }

        @Override
        public Assets.RestrictedQuery orderBy(OrderBy orderBy) {
            throw new IllegalArgumentException("Overriding query result order is not allowed in this rules scope");
        }

        @Override
        public String getResult() {
            ServerAsset asset = assetStorageService.find(this);
            return asset != null ? asset.getId() : null;
        }

        @Override
        public Stream<String> stream() {
            if (this.select == null)
                this.select = new Select();
            Include oldValue = this.select.include;
            this.select.include = Include.ONLY_ID_AND_NAME;
            try {
                return assetStorageService.findAll(this).stream().map(Asset::getId);
            } finally {
                this.select.include = oldValue;
            }
        }
    };
    if (TenantRuleset.class.isAssignableFrom(rulesEngineId.getScope())) {
        query.tenant = new TenantPredicate(rulesEngineId.getRealmId().orElseThrow(() -> new IllegalArgumentException("Realm ID missing: " + rulesEngineId)));
    }
    if (AssetRuleset.class.isAssignableFrom(rulesEngineId.getScope())) {
        ServerAsset restrictedAsset = assetStorageService.find(rulesEngineId.getAssetId().orElseThrow(() -> new IllegalStateException("Asset ID missing: " + rulesEngineId)), true);
        if (restrictedAsset == null) {
            throw new IllegalStateException("Asset is no longer available: " + rulesEngineId);
        }
        query.path = new PathPredicate(restrictedAsset.getPath());
    }
    return query;
}

Example 39 with Asset

use of org.openremote.model.asset.Asset in project openremote by openremote.

the class PersistenceService method init.

@Override
public void init(Container container) throws Exception {
    this.messageBrokerService = container.hasService(MessageBrokerService.class) ? container.getService(MessageBrokerService.class) : null;
    String dbVendor = getString(container.getConfig(), DB_VENDOR, DB_VENDOR_DEFAULT).toUpperCase(Locale.ROOT);
    LOG.info("Preparing persistence service for database: " + dbVendor);
    try {
        database = Database.Product.valueOf(dbVendor);
    } catch (Exception e) {
        LOG.severe("Requested DB_VENDOR is not supported: " + dbVendor);
        throw new UnsupportedOperationException("Requested DB_VENDOR is not supported: " + dbVendor);
    }
    String dbHost = getString(container.getConfig(), DB_HOST, DB_HOST_DEFAULT);
    int dbPort = getInteger(container.getConfig(), DB_PORT, DB_PORT_DEFAULT);
    String dbName = getString(container.getConfig(), DB_NAME, DB_NAME_DEFAULT);
    String dbSchema = getString(container.getConfig(), DB_SCHEMA, DB_SCHEMA_DEFAULT);
    String dbUsername = getString(container.getConfig(), DB_USERNAME, DB_USERNAME_DEFAULT);
    String dbPassword = getString(container.getConfig(), DB_PASSWORD, DB_PASSWORD_DEFAULT);
    String connectionUrl = "jdbc:" + database.getConnectorName() + "://" + dbHost + ":" + dbPort + "/" + dbName;
    connectionUrl = UriBuilder.fromUri(connectionUrl).replaceQueryParam("currentSchema", dbSchema).build().toString();
    persistenceUnitProperties = database.createProperties();
    if (messageBrokerService != null) {
        persistenceUnitProperties.put(AvailableSettings.SESSION_SCOPED_INTERCEPTOR, PersistenceEventInterceptor.class.getName());
    }
    persistenceUnitProperties.put(AvailableSettings.DEFAULT_SCHEMA, dbSchema);
    // Add custom integrator so we can register a custom flush entity event listener
    persistenceUnitProperties.put(EntityManagerFactoryBuilderImpl.INTEGRATOR_PROVIDER, IntegratorProvider.class.getName());
    persistenceUnitName = getString(container.getConfig(), PERSISTENCE_UNIT_NAME, PERSISTENCE_UNIT_NAME_DEFAULT);
    forceClean = getBoolean(container.getConfig(), SETUP_WIPE_CLEAN_INSTALL, container.isDevMode());
    openDatabase(container, database, dbUsername, dbPassword, connectionUrl);
    prepareSchema(connectionUrl, dbUsername, dbPassword, dbSchema);
    // Register standard entity classes and also any Entity ClassProviders
    List<String> entityClasses = new ArrayList<>(50);
    entityClasses.add(Asset.class.getName());
    entityClasses.add(UserAssetLink.class.getName());
    entityClasses.add(AssetDatapoint.class.getName());
    entityClasses.add(SentNotification.class.getName());
    entityClasses.add(AssetPredictedDatapoint.class.getName());
    entityClasses.add(Tenant.class.getName());
    entityClasses.add(User.class.getName());
    entityClasses.add(UserAttribute.class.getName());
    entityClasses.add(RealmRole.class.getName());
    entityClasses.add(GlobalRuleset.class.getName());
    entityClasses.add(AssetRuleset.class.getName());
    entityClasses.add(TenantRuleset.class.getName());
    entityClasses.add(SyslogEvent.class.getName());
    entityClasses.add(GatewayConnection.class.getName());
    entityClasses.add(ConsoleAppConfig.class.getName());
    entityClasses.add(ProvisioningConfig.class.getName());
    entityClasses.add(X509ProvisioningConfig.class.getName());
    // Add packages with package-info (don't think this is JPA spec but hibernate specific)
    entityClasses.add("org.openremote.container.persistence");
    entityClasses.add("org.openremote.container.util");
    // Get asset sub type entities from asset model
    Arrays.stream(ValueUtil.getAssetDescriptors(null)).map(AssetDescriptor::getType).filter(assetClass -> assetClass.getAnnotation(Entity.class) != null).map(Class::getName).forEach(entityClasses::add);
    // Get any entity class providers from the service loader
    ServiceLoader<EntityClassProvider> entityClassProviders = ServiceLoader.load(EntityClassProvider.class);
    entityClassProviders.forEach(entityClassProvider -> entityClassProvider.getEntityClasses().stream().filter(entityClass -> entityClass.getAnnotation(Entity.class) != null).map(Class::getName).forEach(entityClasses::add));
    this.entityManagerFactory = getEntityManagerFactory(persistenceUnitProperties, entityClasses);
// Persistence.createEntityManagerFactory(persistenceUnitName, persistenceUnitProperties);
}

Example 40 with Asset

use of org.openremote.model.asset.Asset in project openremote by openremote.

the class AssetsFacade method getResults.

@Override
public Stream<Asset<?>> getResults(AssetQuery assetQuery) {
    if (TenantRuleset.class.isAssignableFrom(rulesEngineId.getScope())) {
        // Realm is restricted to rules
        assetQuery.tenant = new TenantPredicate(rulesEngineId.getRealm().orElseThrow(() -> new IllegalArgumentException("Realm missing: " + rulesEngineId)));
    } else if (AssetRuleset.class.isAssignableFrom(rulesEngineId.getScope())) {
        // Realm is restricted to assets'
        assetQuery.tenant = new TenantPredicate(rulesEngineId.getRealm().orElseThrow(() -> new IllegalArgumentException("Realm missing: " + rulesEngineId)));
        Asset<?> restrictedAsset = assetStorageService.find(rulesEngineId.getAssetId().orElseThrow(() -> new IllegalStateException("Asset ID missing: " + rulesEngineId)), true);
        if (restrictedAsset == null) {
            throw new IllegalStateException("Asset is no longer available: " + rulesEngineId);
        }
        assetQuery.paths(new PathPredicate(restrictedAsset.getPath()));
    }
    AssetQuery.Select oldValue = assetQuery.select;
    assetQuery.select = new AssetQuery.Select().excludeAttributes();
    try {
        return assetStorageService.findAll(assetQuery).stream();
    } finally {
        assetQuery.select = oldValue;
    }
}