Examples with TechnicalException io.gravitee.repository.exceptions.TechnicalException used on opensource projects

Example 41 with TechnicalException

use of io.gravitee.repository.exceptions.TechnicalException in project gravitee-management-rest-api by gravitee-io.

the class RoleServiceImpl method create.

@Override
public RoleEntity create(final NewRoleEntity roleEntity) {
    try {
        Role role = convert(roleEntity);
        if (roleRepository.findById(role.getScope(), role.getName()).isPresent()) {
            throw new RoleAlreadyExistsException(role.getScope(), role.getName());
        }
        role.setCreatedAt(new Date());
        role.setUpdatedAt(role.getCreatedAt());
        RoleEntity entity = convert(roleRepository.create(role));
        auditService.createPortalAuditLog(Collections.singletonMap(ROLE, role.getScope() + ":" + role.getName()), ROLE_CREATED, role.getCreatedAt(), null, role);
        if (entity.isDefaultRole()) {
            toggleDefaultRole(convert(roleEntity.getScope()), entity.getName());
        }
        return entity;
    } catch (TechnicalException ex) {
        LOGGER.error("An error occurs while trying to create role {}", roleEntity.getName(), ex);
        throw new TechnicalManagementException("An error occurs while trying to create role " + roleEntity.getName(), ex);
    }
}

Example 42 with TechnicalException

use of io.gravitee.repository.exceptions.TechnicalException in project gravitee-management-rest-api by gravitee-io.

the class RoleServiceImpl method update.

@Override
public RoleEntity update(final UpdateRoleEntity roleEntity) {
    if (isReserved(roleEntity.getName())) {
        throw new RoleReservedNameException(SystemRole.ADMIN.name());
    }
    RoleScope scope = convert(roleEntity.getScope());
    try {
        Optional<Role> optRole = roleRepository.findById(scope, roleEntity.getName());
        if (!optRole.isPresent()) {
            throw new RoleNotFoundException(scope, roleEntity.getName());
        }
        Role role = optRole.get();
        Role updatedRole = convert(roleEntity);
        updatedRole.setCreatedAt(role.getCreatedAt());
        RoleEntity entity = convert(roleRepository.update(updatedRole));
        auditService.createPortalAuditLog(Collections.singletonMap(ROLE, role.getScope() + ":" + role.getName()), ROLE_UPDATED, updatedRole.getUpdatedAt(), role, updatedRole);
        if (entity.isDefaultRole()) {
            toggleDefaultRole(scope, entity.getName());
        }
        return entity;
    } catch (TechnicalException ex) {
        LOGGER.error("An error occurs while trying to update role {}", roleEntity.getName(), ex);
        throw new TechnicalManagementException("An error occurs while trying to update role " + roleEntity.getName(), ex);
    }
}

Example 43 with TechnicalException

use of io.gravitee.repository.exceptions.TechnicalException in project gravitee-management-rest-api by gravitee-io.

the class SubscriptionServiceImpl method create.

@Override
public SubscriptionEntity create(NewSubscriptionEntity newSubscriptionEntity) {
    String plan = newSubscriptionEntity.getPlan();
    String application = newSubscriptionEntity.getApplication();
    try {
        logger.debug("Create a new subscription for plan {} and application {}", plan, application);
        PlanEntity planEntity = planService.findById(plan);
        if (planEntity.getStatus() == PlanStatus.CLOSED) {
            throw new PlanAlreadyClosedException(plan);
        }
        if (planEntity.getStatus() == PlanStatus.STAGING) {
            throw new PlanNotYetPublishedException(plan);
        }
        if (planEntity.getSecurity() == PlanSecurityType.KEY_LESS) {
            throw new PlanNotSubscribableException("A key_less plan is not subscribable !");
        }
        ApplicationEntity applicationEntity = applicationService.findById(application);
        // Check existing subscriptions
        List<Subscription> subscriptions = subscriptionRepository.search(new SubscriptionCriteria.Builder().applications(Collections.singleton(application)).apis(planEntity.getApis()).build());
        if (!subscriptions.isEmpty()) {
            Predicate<Subscription> onlyValidSubs = subscription -> subscription.getStatus() != Subscription.Status.REJECTED && subscription.getStatus() != Subscription.Status.CLOSED;
            // First, check that there is no subscription to the same plan
            long subscriptionCount = subscriptions.stream().filter(onlyValidSubs).filter(subscription -> subscription.getPlan().equals(plan)).count();
            if (subscriptionCount > 0) {
                throw new PlanAlreadySubscribedException(plan);
            }
            // Check that there is no existing subscription based on an OAuth2 or JWT plan
            if (planEntity.getSecurity() == PlanSecurityType.OAUTH2 || planEntity.getSecurity() == PlanSecurityType.JWT) {
                long count = subscriptions.stream().filter(onlyValidSubs).map(Subscription::getPlan).distinct().map(plan1 -> planService.findById(plan1)).filter(subPlan -> subPlan.getSecurity() == PlanSecurityType.OAUTH2 || subPlan.getSecurity() == PlanSecurityType.JWT).count();
                if (count > 0) {
                    throw new PlanNotSubscribableException("An other OAuth2 or JWT plan is already subscribed by the same application.");
                }
            }
        }
        if (planEntity.getSecurity() == PlanSecurityType.OAUTH2 || planEntity.getSecurity() == PlanSecurityType.JWT) {
            // Check that the application contains a client_id
            if (applicationEntity.getClientId() == null || applicationEntity.getClientId().trim().isEmpty()) {
                throw new PlanNotSubscribableException("A client_id is required to subscribe to an OAuth2 or JWT plan.");
            }
        }
        Subscription subscription = new Subscription();
        subscription.setPlan(plan);
        subscription.setId(UUID.toString(UUID.random()));
        subscription.setApplication(application);
        subscription.setCreatedAt(new Date());
        subscription.setUpdatedAt(subscription.getCreatedAt());
        subscription.setStatus(Subscription.Status.PENDING);
        subscription.setRequest(newSubscriptionEntity.getRequest());
        subscription.setSubscribedBy(getAuthenticatedUser().getUsername());
        subscription.setClientId(applicationEntity.getClientId());
        String apiId = planEntity.getApis().iterator().next();
        subscription.setApi(apiId);
        subscription = subscriptionRepository.create(subscription);
        createAudit(apiId, application, SUBSCRIPTION_CREATED, subscription.getCreatedAt(), null, subscription);
        final ApiModelEntity api = apiService.findByIdForTemplates(apiId);
        final PrimaryOwnerEntity apiOwner = api.getPrimaryOwner();
        // final PrimaryOwnerEntity appOwner = applicationEntity.getPrimaryOwner();
        String portalUrl = environment.getProperty("portalURL");
        String subscriptionsUrl = "";
        if (portalUrl != null) {
            if (portalUrl.endsWith("/")) {
                portalUrl = portalUrl.substring(0, portalUrl.length() - 1);
            }
            subscriptionsUrl = portalUrl + "/#!/management/apis/" + api.getId() + "/subscriptions/" + subscription.getId();
        }
        final Map<String, Object> params = new NotificationParamsBuilder().api(api).plan(planEntity).application(applicationEntity).owner(apiOwner).subscription(convert(subscription)).subscriptionsUrl(subscriptionsUrl).build();
        if (PlanValidationType.AUTO == planEntity.getValidation()) {
            ProcessSubscriptionEntity process = new ProcessSubscriptionEntity();
            process.setId(subscription.getId());
            process.setAccepted(true);
            process.setStartingAt(new Date());
            // Do process
            return process(process, SUBSCRIPTION_SYSTEM_VALIDATOR);
        } else {
            notifierService.trigger(ApiHook.SUBSCRIPTION_NEW, apiId, params);
            notifierService.trigger(ApplicationHook.SUBSCRIPTION_NEW, application, params);
            return convert(subscription);
        }
    } catch (TechnicalException ex) {
        logger.error("An error occurs while trying to subscribe to the plan {}", plan, ex);
        throw new TechnicalManagementException(String.format("An error occurs while trying to subscribe to the plan %s", plan), ex);
    }
}

Example 44 with TechnicalException

use of io.gravitee.repository.exceptions.TechnicalException in project gravitee-management-rest-api by gravitee-io.

the class SubscriptionServiceImpl method process.

@Override
public SubscriptionEntity process(ProcessSubscriptionEntity processSubscription, String userId) {
    try {
        logger.debug("Subscription {} processed by {}", processSubscription.getId(), userId);
        Optional<Subscription> optSubscription = subscriptionRepository.findById(processSubscription.getId());
        if (!optSubscription.isPresent()) {
            throw new SubscriptionNotFoundException(processSubscription.getId());
        }
        Subscription subscription = optSubscription.get();
        Subscription previousSubscription = new Subscription(subscription);
        if (subscription.getStatus() != Subscription.Status.PENDING) {
            throw new SubscriptionAlreadyProcessedException(subscription.getId());
        }
        PlanEntity planEntity = planService.findById(subscription.getPlan());
        if (planEntity.getStatus() == PlanStatus.CLOSED) {
            throw new PlanAlreadyClosedException(planEntity.getId());
        }
        subscription.setProcessedBy(userId);
        subscription.setProcessedAt(new Date());
        if (processSubscription.isAccepted()) {
            subscription.setStatus(Subscription.Status.ACCEPTED);
            subscription.setStartingAt((processSubscription.getStartingAt() != null) ? processSubscription.getStartingAt() : new Date());
            subscription.setEndingAt(processSubscription.getEndingAt());
            subscription.setReason(processSubscription.getReason());
        } else {
            subscription.setStatus(Subscription.Status.REJECTED);
            subscription.setReason(processSubscription.getReason());
            subscription.setClosedAt(new Date());
        }
        subscription = subscriptionRepository.update(subscription);
        final ApplicationEntity application = applicationService.findById(subscription.getApplication());
        final PlanEntity plan = planService.findById(subscription.getPlan());
        final String apiId = plan.getApis().iterator().next();
        final ApiModelEntity api = apiService.findByIdForTemplates(apiId);
        final PrimaryOwnerEntity owner = application.getPrimaryOwner();
        createAudit(apiId, subscription.getApplication(), SUBSCRIPTION_UPDATED, subscription.getUpdatedAt(), previousSubscription, subscription);
        SubscriptionEntity subscriptionEntity = convert(subscription);
        final Map<String, Object> params = new NotificationParamsBuilder().owner(owner).application(application).api(api).plan(plan).subscription(subscriptionEntity).build();
        if (subscription.getStatus() == Subscription.Status.ACCEPTED) {
            notifierService.trigger(ApiHook.SUBSCRIPTION_ACCEPTED, apiId, params);
            notifierService.trigger(ApplicationHook.SUBSCRIPTION_ACCEPTED, application.getId(), params);
        } else {
            notifierService.trigger(ApiHook.SUBSCRIPTION_REJECTED, apiId, params);
            notifierService.trigger(ApplicationHook.SUBSCRIPTION_REJECTED, application.getId(), params);
        }
        if (plan.getSecurity() == PlanSecurityType.API_KEY && subscription.getStatus() == Subscription.Status.ACCEPTED) {
            apiKeyService.generate(subscription.getId());
        }
        return subscriptionEntity;
    } catch (TechnicalException ex) {
        logger.error("An error occurs while trying to process subscription {} by {}", processSubscription.getId(), userId, ex);
        throw new TechnicalManagementException(String.format("An error occurs while trying to process subscription %s by %s", processSubscription.getId(), userId), ex);
    }
}

Example 45 with TechnicalException

use of io.gravitee.repository.exceptions.TechnicalException in project gravitee-management-rest-api by gravitee-io.

the class SubscriptionServiceImpl method update.

@Override
public SubscriptionEntity update(UpdateSubscriptionEntity updateSubscription, String clientId) {
    try {
        logger.debug("Update subscription {}", updateSubscription.getId());
        Optional<Subscription> optSubscription = subscriptionRepository.findById(updateSubscription.getId());
        if (!optSubscription.isPresent()) {
            throw new SubscriptionNotFoundException(updateSubscription.getId());
        }
        Subscription subscription = optSubscription.get();
        if (subscription.getStatus() == Subscription.Status.ACCEPTED) {
            Subscription previousSubscription = new Subscription(subscription);
            subscription.setUpdatedAt(new Date());
            subscription.setStartingAt(updateSubscription.getStartingAt());
            subscription.setEndingAt(updateSubscription.getEndingAt());
            if (clientId != null) {
                subscription.setClientId(clientId);
            }
            subscription = subscriptionRepository.update(subscription);
            final PlanEntity plan = planService.findById(subscription.getPlan());
            createAudit(plan.getApis().iterator().next(), subscription.getApplication(), SUBSCRIPTION_UPDATED, subscription.getUpdatedAt(), previousSubscription, subscription);
            // Update the expiration date for not yet revoked api-keys relative to this subscription
            Date endingAt = subscription.getEndingAt();
            if (plan.getSecurity() == PlanSecurityType.API_KEY && endingAt != null) {
                Set<ApiKeyEntity> apiKeys = apiKeyService.findBySubscription(subscription.getId());
                Date now = new Date();
                for (ApiKeyEntity apiKey : apiKeys) {
                    Date expireAt = apiKey.getExpireAt();
                    if (!apiKey.isRevoked() && (expireAt == null || expireAt.equals(now) || expireAt.before(now))) {
                        apiKey.setExpireAt(endingAt);
                        apiKeyService.update(apiKey);
                    }
                }
            }
            return convert(subscription);
        }
        throw new SubscriptionNotUpdatableException(updateSubscription.getId());
    } catch (TechnicalException ex) {
        logger.error("An error occurs while trying to update subscription {}", updateSubscription.getId(), ex);
        throw new TechnicalManagementException(String.format("An error occurs while trying to update subscription %s", updateSubscription.getId()), ex);
    }
}