Examples with Model com.amplifyframework.core.model.Model used on opensource projects

Example 11 with Model

use of com.amplifyframework.core.model.Model in project amplify-android by aws-amplify.

the class ModelWithMetadataAdapter method deserialize.

@Override
// Cast Type to Class<? extends Model>
@SuppressWarnings("unchecked")
public ModelWithMetadata<? extends Model> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    final Class<? extends Model> modelClassType;
    if (typeOfT instanceof ParameterizedType) {
        // Because typeOfT is ParameterizedType we can be sure this is a safe cast.
        modelClassType = (Class<? extends Model>) ((ParameterizedType) typeOfT).getActualTypeArguments()[0];
    } else {
        throw new JsonParseException("Expected a parameterized type during ModelWithMetadata deserialization.");
    }
    final Model model;
    ModelMetadata metadata = context.deserialize(json, ModelMetadata.class);
    if (modelClassType == SerializedModel.class) {
        JsonObject jsonObject = (JsonObject) json;
        // remove metadata fields from the serialized model so it matches the schema
        removeMetadataFields(jsonObject);
        model = SerializedModel.builder().serializedData(GsonObjectConverter.toMap(jsonObject)).modelSchema(null).build();
    } else {
        model = context.deserialize(json, modelClassType);
    }
    return new ModelWithMetadata<>(model, metadata);
}

Example 12 with Model

use of com.amplifyframework.core.model.Model in project amplify-android by aws-amplify.

the class SQLiteStorageAdapter method query.

/**
 * {@inheritDoc}
 */
@Override
public void query(@NonNull String modelName, @NonNull QueryOptions options, @NonNull Consumer<Iterator<? extends Model>> onSuccess, @NonNull Consumer<DataStoreException> onError) {
    Objects.requireNonNull(modelName);
    Objects.requireNonNull(options);
    Objects.requireNonNull(onSuccess);
    Objects.requireNonNull(onError);
    threadPool.submit(() -> {
        final ModelSchema modelSchema = schemaRegistry.getModelSchemaForModelClass(modelName);
        try (Cursor cursor = sqlCommandProcessor.rawQuery(sqlCommandFactory.queryFor(modelSchema, options))) {
            LOG.debug("Querying item for: " + modelName);
            final List<Model> models = new ArrayList<>();
            final SQLiteModelFieldTypeConverter converter = new SQLiteModelFieldTypeConverter(modelSchema, schemaRegistry, gson);
            if (cursor == null) {
                onError.accept(new DataStoreException("Error in getting a cursor to the table for class: " + modelName, AmplifyException.TODO_RECOVERY_SUGGESTION));
                return;
            }
            if (cursor.moveToFirst()) {
                do {
                    final Map<String, Object> data = converter.buildMapForModel(cursor);
                    final SerializedModel model = createSerializedModel(modelSchema, data);
                    models.add(model);
                } while (cursor.moveToNext());
            }
            onSuccess.accept(models.iterator());
        } catch (Exception exception) {
            onError.accept(new DataStoreException("Error in querying the model.", exception, "See attached exception for details."));
        }
    });
}

Example 13 with Model

use of com.amplifyframework.core.model.Model in project amplify-android by aws-amplify.

the class SQLiteStorageAdapter method delete.

/**
 * {@inheritDoc}
 */
@Override
public <T extends Model> void delete(@NonNull T item, @NonNull StorageItemChange.Initiator initiator, @NonNull QueryPredicate predicate, @NonNull Consumer<StorageItemChange<T>> onSuccess, @NonNull Consumer<DataStoreException> onError) {
    Objects.requireNonNull(item);
    Objects.requireNonNull(initiator);
    Objects.requireNonNull(predicate);
    Objects.requireNonNull(onSuccess);
    Objects.requireNonNull(onError);
    threadPool.submit(() -> {
        try {
            final String modelName = item.getModelName();
            final ModelSchema modelSchema = schemaRegistry.getModelSchemaForModelClass(modelName);
            // Check if data being deleted exists; "Succeed" deletion in that case.
            if (!sqlQueryProcessor.modelExists(item, QueryPredicates.all())) {
                LOG.verbose(modelName + " model with id = " + item.getId() + " does not exist.");
                // Pass back item change instance without publishing it.
                onSuccess.accept(StorageItemChange.<T>builder().item(item).patchItem(SerializedModel.create(item, modelSchema)).modelSchema(modelSchema).type(StorageItemChange.Type.DELETE).predicate(predicate).initiator(initiator).build());
                return;
            }
            // Check if existing data meets the condition, only if a condition other than all() was provided.
            if (!QueryPredicates.all().equals(predicate) && !sqlQueryProcessor.modelExists(item, predicate)) {
                throw new DataStoreException("Deletion failed because condition did not match existing model instance.", "The deletion will continue to fail until the model instance is updated.");
            }
            // identify items affected by cascading delete before deleting them
            List<Model> cascadedModels = sqliteModelTree.descendantsOf(Collections.singleton(item));
            // execute local deletion
            writeData(item, StorageItemChange.Type.DELETE);
            // publish cascaded deletions
            for (Model cascadedModel : cascadedModels) {
                ModelSchema schema = schemaRegistry.getModelSchemaForModelClass(cascadedModel.getModelName());
                itemChangeSubject.onNext(StorageItemChange.builder().item(cascadedModel).patchItem(SerializedModel.create(cascadedModel, schema)).modelSchema(schema).type(StorageItemChange.Type.DELETE).predicate(QueryPredicates.all()).initiator(initiator).build());
            }
            // publish successful deletion of top-level item
            StorageItemChange<T> change = StorageItemChange.<T>builder().item(item).patchItem(SerializedModel.create(item, modelSchema)).modelSchema(modelSchema).type(StorageItemChange.Type.DELETE).predicate(predicate).initiator(initiator).build();
            itemChangeSubject.onNext(change);
            onSuccess.accept(change);
        } catch (DataStoreException dataStoreException) {
            onError.accept(dataStoreException);
        } catch (Exception someOtherTypeOfException) {
            DataStoreException dataStoreException = new DataStoreException("Error in deleting the model.", someOtherTypeOfException, "See attached exception for details.");
            onError.accept(dataStoreException);
        }
    });
}

Example 14 with Model

use of com.amplifyframework.core.model.Model in project amplify-android by aws-amplify.

the class SQLiteStorageAdapter method query.

/**
 * Helper method to synchronously query for a single model instance.  Used before any save initiated by
 * DATASTORE_API in order to determine which fields have changed.
 * @param model a Model that we want to query for the same type and id in SQLite.
 * @return the Model instance from SQLite, if it exists, otherwise null.
 */
private Model query(Model model) {
    final String modelName = model.getModelName();
    final ModelSchema schema = schemaRegistry.getModelSchemaForModelClass(modelName);
    final SQLiteTable table = SQLiteTable.fromSchema(schema);
    final String primaryKeyName = table.getPrimaryKey().getName();
    final QueryPredicate matchId = QueryField.field(modelName, primaryKeyName).eq(model.getId());
    Iterator<? extends Model> result = Single.<Iterator<? extends Model>>create(emitter -> {
        if (model instanceof SerializedModel) {
            query(model.getModelName(), Where.matches(matchId), emitter::onSuccess, emitter::onError);
        } else {
            query(model.getClass(), Where.matches(matchId), emitter::onSuccess, emitter::onError);
        }
    }).blockingGet();
    return result.hasNext() ? result.next() : null;
}

Example 15 with Model

use of com.amplifyframework.core.model.Model in project amplify-android by aws-amplify.

the class SQLiteStorageAdapter method delete.

/**
 * {@inheritDoc}
 */
@Override
public <T extends Model> void delete(@NonNull Class<T> itemClass, @NonNull StorageItemChange.Initiator initiator, @NonNull QueryPredicate predicate, @NonNull Action onSuccess, @NonNull Consumer<DataStoreException> onError) {
    Objects.requireNonNull(itemClass);
    Objects.requireNonNull(initiator);
    Objects.requireNonNull(predicate);
    Objects.requireNonNull(onSuccess);
    Objects.requireNonNull(onError);
    threadPool.submit(() -> {
        final ModelSchema modelSchema = schemaRegistry.getModelSchemaForModelClass(itemClass);
        QueryOptions options = Where.matches(predicate);
        try (Cursor cursor = sqlCommandProcessor.rawQuery(sqlCommandFactory.queryFor(modelSchema, options))) {
            final SQLiteTable sqliteTable = SQLiteTable.fromSchema(modelSchema);
            final String primaryKeyName = sqliteTable.getPrimaryKey().getAliasedName();
            // identify items that meet the predicate
            List<T> items = new ArrayList<>();
            if (cursor != null && cursor.moveToFirst()) {
                int index = cursor.getColumnIndexOrThrow(primaryKeyName);
                do {
                    String id = cursor.getString(index);
                    String dummyJson = gson.toJson(Collections.singletonMap("id", id));
                    T dummyItem = gson.fromJson(dummyJson, itemClass);
                    items.add(dummyItem);
                } while (cursor.moveToNext());
            }
            // identify every model to delete as a result of this operation
            List<Model> modelsToDelete = new ArrayList<>(items);
            List<Model> cascadedModels = sqliteModelTree.descendantsOf(items);
            modelsToDelete.addAll(cascadedModels);
            // execute local deletions
            sqlCommandProcessor.execute(sqlCommandFactory.deleteFor(modelSchema, predicate));
            // publish every deletion
            for (Model model : modelsToDelete) {
                ModelSchema schema = schemaRegistry.getModelSchemaForModelClass(model.getModelName());
                itemChangeSubject.onNext(StorageItemChange.builder().item(model).patchItem(SerializedModel.create(model, schema)).modelSchema(schema).type(StorageItemChange.Type.DELETE).predicate(QueryPredicates.all()).initiator(initiator).build());
            }
            onSuccess.call();
        } catch (DataStoreException dataStoreException) {
            onError.accept(dataStoreException);
        } catch (Exception someOtherTypeOfException) {
            DataStoreException dataStoreException = new DataStoreException("Error in deleting models.", someOtherTypeOfException, "See attached exception for details.");
            onError.accept(dataStoreException);
        }
    });
}