Examples with AmplifyException com.amplifyframework.AmplifyException used on opensource projects

Example 31 with AmplifyException

use of com.amplifyframework.AmplifyException in project amplify-android by aws-amplify.

the class StorageComponentTest method setup.

/**
 * Sets up Storage category by registering a mock AWSS3StoragePlugin
 * instance to Amplify and configuring.
 *
 * @throws AmplifyException if Amplify fails to configure with mock
 *                          Storage category configuration.
 */
@Before
public void setup() throws AmplifyException {
    this.storage = new StorageCategory();
    this.storageService = mock(StorageService.class);
    StorageService.Factory storageServiceFactory = (context, region, bucket) -> storageService;
    CognitoAuthProvider cognitoAuthProvider = mock(CognitoAuthProvider.class);
    doReturn(RandomString.string()).when(cognitoAuthProvider).getIdentityId();
    this.storage.addPlugin(new AWSS3StoragePlugin(storageServiceFactory, cognitoAuthProvider, new AWSS3StoragePluginConfiguration.Builder().build()));
    this.storage.configure(buildConfiguration(), getApplicationContext());
    this.storage.initialize(getApplicationContext());
}

Example 32 with AmplifyException

use of com.amplifyframework.AmplifyException in project amplify-android by aws-amplify.

the class AppSyncRequestFactory method buildMutation.

/**
 * Builds a mutation.
 * @param schema the model schema for the mutation
 * @param mutationType Type of mutation, e.g. {@link MutationType#CREATE}
 * @param <M> Type of model being mutated
 * @return Mutation doc
 */
private static <M extends Model> AppSyncGraphQLRequest<ModelWithMetadata<M>> buildMutation(ModelSchema schema, Map<String, Object> inputMap, QueryPredicate predicate, MutationType mutationType, AuthModeStrategyType strategyType) throws DataStoreException {
    try {
        String graphQlTypeName = schema.getName();
        AppSyncGraphQLRequest.Builder builder = AppSyncGraphQLRequest.builder().modelClass(schema.getModelClass()).modelSchema(schema).operation(mutationType).requestAuthorizationStrategyType(strategyType).requestOptions(new DataStoreGraphQLRequestOptions()).responseType(TypeMaker.getParameterizedType(ModelWithMetadata.class, schema.getModelClass()));
        String inputType = Casing.capitalize(mutationType.toString()) + Casing.capitalizeFirst(graphQlTypeName) + // CreateTodoInput
        "Input!";
        builder.variable("input", inputType, inputMap);
        if (!QueryPredicates.all().equals(predicate)) {
            String conditionType = "Model" + Casing.capitalizeFirst(graphQlTypeName) + "ConditionInput";
            builder.variable("condition", conditionType, parsePredicate(predicate));
        }
        return builder.build();
    } catch (AmplifyException amplifyException) {
        throw new DataStoreException("Failed to get fields for model.", amplifyException, "Validate your model file.");
    }
}

Example 33 with AmplifyException

use of com.amplifyframework.AmplifyException in project amplify-android by aws-amplify.

the class AuthRuleRequestDecorator method decorate.

/**
 * Decorate given GraphQL request instance with additional variables for owner-based or
 * group-based authorization.
 *
 * This will only work if the request is compliant with the AppSync specifications.
 * @param request an instance of {@link GraphQLRequest}.
 * @param authType the mode of authorization being used to authorize the request
 * @param <R> The type of data contained in the GraphQLResponse expected from this request.
 * @return the input request with additional variables that specify model's owner and/or
 *          groups
 * @throws ApiException If an error is encountered while processing the auth rules associated
 *          with the request or if the authorization fails
 */
public <R> GraphQLRequest<R> decorate(@NonNull GraphQLRequest<R> request, @NonNull AuthorizationType authType) throws ApiException {
    if (!(request instanceof AppSyncGraphQLRequest)) {
        return request;
    }
    AppSyncGraphQLRequest<R> appSyncRequest = (AppSyncGraphQLRequest<R>) request;
    AuthRule ownerRuleWithReadRestriction = null;
    Map<String, Set<String>> readAuthorizedGroupsMap = new HashMap<>();
    // and it's not clear what a good solution would be until AppSync supports real time filters.
    for (AuthRule authRule : appSyncRequest.getModelSchema().getAuthRules()) {
        if (isReadRestrictingOwner(authRule)) {
            if (ownerRuleWithReadRestriction == null) {
                ownerRuleWithReadRestriction = authRule;
            } else {
                throw new ApiAuthException("Detected multiple owner type auth rules with a READ operation", "We currently do not support this use case. Please limit your type to just one owner " + "auth rule with a READ operation restriction.");
            }
        } else if (isReadRestrictingStaticGroup(authRule)) {
            // Group read-restricting groups by the claim name
            String groupClaim = authRule.getGroupClaimOrDefault();
            List<String> groups = authRule.getGroups();
            Set<String> readAuthorizedGroups = readAuthorizedGroupsMap.get(groupClaim);
            if (readAuthorizedGroups != null) {
                readAuthorizedGroups.addAll(groups);
            } else {
                readAuthorizedGroupsMap.put(groupClaim, new HashSet<>(groups));
            }
        }
    }
    // them.
    if (ownerRuleWithReadRestriction != null && userNotInReadRestrictingGroups(readAuthorizedGroupsMap, authType)) {
        String idClaim = ownerRuleWithReadRestriction.getIdentityClaimOrDefault();
        String key = ownerRuleWithReadRestriction.getOwnerFieldOrDefault();
        String value = getIdentityValue(idClaim, authType);
        try {
            return appSyncRequest.newBuilder().variable(key, "String!", value).build();
        } catch (AmplifyException error) {
            // This should not happen normally
            throw new ApiAuthException("Failed to set owner field on AppSyncGraphQLRequest.", error, AmplifyException.REPORT_BUG_TO_AWS_SUGGESTION);
        }
    }
    return request;
}

Example 34 with AmplifyException

use of com.amplifyframework.AmplifyException in project amplify-android by aws-amplify.

the class AppSyncGraphQLRequestFactory method buildMutation.

/**
 * Creates a {@link GraphQLRequest} that represents a mutation of a given type.
 *
 * @param model the model instance.
 * @param predicate the model predicate.
 * @param type the mutation type.
 * @param <R> the response type.
 * @param <T> the concrete model type.
 * @return a valid {@link GraphQLRequest} instance.
 * @throws IllegalStateException when the model schema does not contain the expected information.
 */
public static <R, T extends Model> GraphQLRequest<R> buildMutation(T model, QueryPredicate predicate, MutationType type) {
    try {
        Class<? extends Model> modelClass = model.getClass();
        ModelSchema schema = ModelSchema.fromModelClass(modelClass);
        String graphQlTypeName = schema.getName();
        AppSyncGraphQLRequest.Builder builder = AppSyncGraphQLRequest.builder().operation(type).modelClass(modelClass).requestOptions(new ApiGraphQLRequestOptions()).responseType(modelClass);
        String inputType = Casing.capitalize(type.toString()) + Casing.capitalizeFirst(graphQlTypeName) + // CreateTodoInput
        "Input!";
        if (MutationType.DELETE.equals(type)) {
            builder.variable("input", inputType, getDeleteMutationInputMap(schema, model));
        } else {
            builder.variable("input", inputType, getMapOfFieldNameAndValues(schema, model));
        }
        if (!QueryPredicates.all().equals(predicate)) {
            String conditionType = "Model" + Casing.capitalizeFirst(graphQlTypeName) + "ConditionInput";
            builder.variable("condition", conditionType, parsePredicate(predicate));
        }
        return builder.build();
    } catch (AmplifyException exception) {
        throw new IllegalStateException("Could not generate a schema for the specified class", exception);
    }
}