Examples with PUBLIC io.gravitee.repository.management.model.Visibility.PUBLIC used on opensource projects

Example 6 with PUBLIC

use of io.gravitee.repository.management.model.Visibility.PUBLIC in project gravitee-management-rest-api by gravitee-io.

the class ApiServiceImpl method findByIdForTemplates.

@Override
public ApiModelEntity findByIdForTemplates(String apiId, boolean decodeTemplate) {
    final ApiEntity apiEntity = findById(apiId);
    final ApiModelEntity apiModelEntity = new ApiModelEntity();
    apiModelEntity.setId(apiEntity.getId());
    apiModelEntity.setName(apiEntity.getName());
    apiModelEntity.setDescription(apiEntity.getDescription());
    apiModelEntity.setCreatedAt(apiEntity.getCreatedAt());
    apiModelEntity.setDeployedAt(apiEntity.getDeployedAt());
    apiModelEntity.setUpdatedAt(apiEntity.getUpdatedAt());
    apiModelEntity.setGroups(apiEntity.getGroups());
    apiModelEntity.setVisibility(apiEntity.getVisibility());
    apiModelEntity.setCategories(apiEntity.getCategories());
    apiModelEntity.setVersion(apiEntity.getVersion());
    apiModelEntity.setState(apiEntity.getState());
    apiModelEntity.setTags(apiEntity.getTags());
    apiModelEntity.setServices(apiEntity.getServices());
    apiModelEntity.setPaths(apiEntity.getPaths());
    apiModelEntity.setPicture(apiEntity.getPicture());
    apiModelEntity.setPrimaryOwner(apiEntity.getPrimaryOwner());
    apiModelEntity.setProperties(apiEntity.getProperties());
    apiModelEntity.setProxy(convert(apiEntity.getProxy()));
    apiModelEntity.setLifecycleState(apiEntity.getLifecycleState());
    apiModelEntity.setDisableMembershipNotifications(apiEntity.isDisableMembershipNotifications());
    final List<ApiMetadataEntity> metadataList = apiMetadataService.findAllByApi(apiId);
    if (metadataList != null) {
        final Map<String, String> mapMetadata = new HashMap<>(metadataList.size());
        metadataList.forEach(metadata -> mapMetadata.put(metadata.getKey(), metadata.getValue() == null ? metadata.getDefaultValue() : metadata.getValue()));
        apiModelEntity.setMetadata(mapMetadata);
        if (decodeTemplate) {
            try {
                String decodedValue = this.notificationTemplateService.resolveInlineTemplateWithParam(apiModelEntity.getId(), new StringReader(mapMetadata.toString()), Collections.singletonMap("api", apiModelEntity));
                Map<String, String> metadataDecoded = Arrays.stream(decodedValue.substring(1, decodedValue.length() - 1).split(", ")).map(entry -> entry.split("=")).collect(Collectors.toMap(entry -> entry[0], entry -> entry.length > 1 ? entry[1] : ""));
                apiModelEntity.setMetadata(metadataDecoded);
            } catch (Exception ex) {
                throw new TechnicalManagementException("An error occurs while evaluating API metadata", ex);
            }
        }
    }
    return apiModelEntity;
}

Example 7 with PUBLIC

use of io.gravitee.repository.management.model.Visibility.PUBLIC in project gravitee-management-rest-api by gravitee-io.

the class ApiServiceImpl method update.

@Override
public ApiEntity update(String apiId, UpdateApiEntity updateApiEntity, boolean checkPlans) {
    try {
        LOGGER.debug("Update API {}", apiId);
        Optional<Api> optApiToUpdate = apiRepository.findById(apiId);
        if (!optApiToUpdate.isPresent()) {
            throw new ApiNotFoundException(apiId);
        }
        // check if entrypoints are unique
        final Collection<VirtualHost> sanitizedVirtualHosts = virtualHostService.sanitizeAndValidate(updateApiEntity.getProxy().getVirtualHosts(), apiId);
        updateApiEntity.getProxy().setVirtualHosts(new ArrayList<>(sanitizedVirtualHosts));
        // check endpoints presence
        checkEndpointsExists(updateApiEntity);
        // check endpoints name
        checkEndpointsName(updateApiEntity);
        // check HC inheritance
        checkHealthcheckInheritance(updateApiEntity);
        // validate HC cron schedule
        validateHealtcheckSchedule(updateApiEntity);
        // check CORS Allow-origin format
        checkAllowOriginFormat(updateApiEntity);
        addLoggingMaxDuration(updateApiEntity.getProxy().getLogging());
        // check if there is regex errors in plaintext fields
        validateRegexfields(updateApiEntity);
        // check policy configurations.
        checkPolicyConfigurations(updateApiEntity);
        final ApiEntity apiToCheck = convert(optApiToUpdate.get());
        // if user changes sharding tags, then check if he is allowed to do it
        checkShardingTags(updateApiEntity, apiToCheck);
        // if lifecycle state not provided, set the saved one
        if (updateApiEntity.getLifecycleState() == null) {
            updateApiEntity.setLifecycleState(apiToCheck.getLifecycleState());
        }
        // check lifecycle state
        checkLifecycleState(updateApiEntity, apiToCheck);
        Set<String> groups = updateApiEntity.getGroups();
        if (groups != null && !groups.isEmpty()) {
            // check the existence of groups
            checkGroupExistence(groups);
            // remove PO group if exists
            groups = removePOGroups(groups, apiId);
            updateApiEntity.setGroups(groups);
        }
        // add a default path, if version is v1
        if (Objects.equals(updateApiEntity.getGraviteeDefinitionVersion(), DefinitionVersion.V1.getLabel()) && (updateApiEntity.getPaths() == null || updateApiEntity.getPaths().isEmpty())) {
            updateApiEntity.setPaths(singletonMap("/", new ArrayList<>()));
        }
        if (updateApiEntity.getPlans() == null) {
            updateApiEntity.setPlans(new ArrayList<>());
        } else if (checkPlans) {
            List<Plan> existingPlans = apiToCheck.getPlans();
            Map<String, String> planStatuses = new HashMap<>();
            if (existingPlans != null && !existingPlans.isEmpty()) {
                planStatuses.putAll(existingPlans.stream().collect(toMap(Plan::getId, Plan::getStatus)));
            }
            updateApiEntity.getPlans().forEach(planToUpdate -> {
                if (!planStatuses.containsKey(planToUpdate.getId()) || (planStatuses.containsKey(planToUpdate.getId()) && planStatuses.get(planToUpdate.getId()).equalsIgnoreCase(PlanStatus.CLOSED.name()) && !planStatuses.get(planToUpdate.getId()).equalsIgnoreCase(planToUpdate.getStatus()))) {
                    throw new InvalidDataException("Invalid status for plan '" + planToUpdate.getName() + "'");
                }
            });
        }
        Api apiToUpdate = optApiToUpdate.get();
        if (io.gravitee.rest.api.model.api.ApiLifecycleState.DEPRECATED.equals(updateApiEntity.getLifecycleState())) {
            planService.findByApi(apiId).forEach(plan -> {
                if (PlanStatus.PUBLISHED.equals(plan.getStatus()) || PlanStatus.STAGING.equals(plan.getStatus())) {
                    planService.deprecate(plan.getId(), true);
                    updateApiEntity.getPlans().stream().filter(p -> p.getId().equals(plan.getId())).forEach(p -> p.setStatus(PlanStatus.DEPRECATED.name()));
                }
            });
        }
        Api api = convert(apiId, updateApiEntity, apiToUpdate.getDefinition());
        if (api != null) {
            api.setId(apiId.trim());
            api.setUpdatedAt(new Date());
            // Copy fields from existing values
            api.setEnvironmentId(apiToUpdate.getEnvironmentId());
            api.setDeployedAt(apiToUpdate.getDeployedAt());
            api.setCreatedAt(apiToUpdate.getCreatedAt());
            api.setLifecycleState(apiToUpdate.getLifecycleState());
            // If no new picture and the current picture url is not the default one, keep the current picture
            if (updateApiEntity.getPicture() == null && updateApiEntity.getPictureUrl() != null && updateApiEntity.getPictureUrl().indexOf("?hash") > 0) {
                api.setPicture(apiToUpdate.getPicture());
            }
            if (updateApiEntity.getBackground() == null && updateApiEntity.getBackgroundUrl() != null && updateApiEntity.getBackgroundUrl().indexOf("?hash") > 0) {
                api.setBackground(apiToUpdate.getBackground());
            }
            if (updateApiEntity.getGroups() == null) {
                api.setGroups(apiToUpdate.getGroups());
            }
            if (updateApiEntity.getLabels() == null && apiToUpdate.getLabels() != null) {
                api.setLabels(new ArrayList<>(new HashSet<>(apiToUpdate.getLabels())));
            }
            if (updateApiEntity.getCategories() == null) {
                api.setCategories(apiToUpdate.getCategories());
            }
            if (ApiLifecycleState.DEPRECATED.equals(api.getApiLifecycleState())) {
                notifierService.trigger(ApiHook.API_DEPRECATED, apiId, new NotificationParamsBuilder().api(apiToCheck).user(userService.findById(getAuthenticatedUsername())).build());
            }
            Api updatedApi = apiRepository.update(api);
            // Audit
            auditService.createApiAuditLog(updatedApi.getId(), Collections.emptyMap(), API_UPDATED, updatedApi.getUpdatedAt(), apiToUpdate, updatedApi);
            if (parameterService.findAsBoolean(Key.LOGGING_AUDIT_TRAIL_ENABLED, ParameterReferenceType.ENVIRONMENT)) {
                // Audit API logging if option is enabled
                auditApiLogging(apiToUpdate, updatedApi);
            }
            ApiEntity apiEntity = convert(singletonList(updatedApi)).iterator().next();
            ApiEntity apiWithMetadata = fetchMetadataForApi(apiEntity);
            searchEngineService.index(apiWithMetadata, false);
            return apiEntity;
        } else {
            LOGGER.error("Unable to update API {} because of previous error.", apiId);
            throw new TechnicalManagementException("Unable to update API " + apiId);
        }
    } catch (TechnicalException ex) {
        LOGGER.error("An error occurs while trying to update API {}", apiId, ex);
        throw new TechnicalManagementException("An error occurs while trying to update API " + apiId, ex);
    }
}

Example 8 with PUBLIC

use of io.gravitee.repository.management.model.Visibility.PUBLIC in project gravitee-management-rest-api by gravitee-io.

the class ApiServiceImpl method fetchMetadataForApi.

@Override
public ApiEntity fetchMetadataForApi(ApiEntity apiEntity) {
    List<ApiMetadataEntity> metadataList = apiMetadataService.findAllByApi(apiEntity.getId());
    final Map<String, Object> mapMetadata = new HashMap<>(metadataList.size());
    metadataList.forEach(metadata -> mapMetadata.put(metadata.getKey(), metadata.getValue() == null ? metadata.getDefaultValue() : metadata.getValue()));
    String decodedValue = this.notificationTemplateService.resolveInlineTemplateWithParam(apiEntity.getId(), new StringReader(mapMetadata.toString()), Collections.singletonMap("api", apiEntity));
    Map<String, Object> metadataDecoded = Arrays.stream(decodedValue.substring(1, decodedValue.length() - 1).split(", ")).map(entry -> entry.split("=")).collect(Collectors.toMap(entry -> entry[0], entry -> entry.length > 1 ? entry[1] : ""));
    apiEntity.setMetadata(metadataDecoded);
    return apiEntity;
}

Example 9 with PUBLIC

use of io.gravitee.repository.management.model.Visibility.PUBLIC in project gravitee-management-rest-api by gravitee-io.

the class ApiServiceImpl method findApisByUser.

private List<Api> findApisByUser(String userId, ApiQuery apiQuery, boolean portal) {
    // get all public apis
    List<Api> publicApis;
    if (portal) {
        publicApis = apiRepository.search(queryToCriteria(apiQuery).visibility(PUBLIC).build());
    } else {
        publicApis = emptyList();
    }
    List<Api> userApis = emptyList();
    List<Api> groupApis = emptyList();
    List<Api> subscribedApis = emptyList();
    // for others API, user must be authenticated
    if (userId != null) {
        // get user apis
        final String[] userApiIds = membershipService.getMembershipsByMemberAndReference(MembershipMemberType.USER, userId, MembershipReferenceType.API).stream().map(MembershipEntity::getReferenceId).filter(apiId -> {
            if (apiQuery != null && !CollectionUtils.isEmpty(apiQuery.getIds())) {
                // We already have api ids to focus on.
                return apiQuery.getIds().contains(apiId);
            } else {
                return true;
            }
        }).toArray(String[]::new);
        if (userApiIds.length > 0) {
            userApis = apiRepository.search(queryToCriteria(apiQuery).ids(userApiIds).build());
        }
        // get user groups apis
        final String[] groupIds = membershipService.getMembershipsByMemberAndReference(MembershipMemberType.USER, userId, MembershipReferenceType.GROUP).stream().filter(m -> {
            final RoleEntity roleInGroup = roleService.findById(m.getRoleId());
            if (!portal) {
                return (m.getRoleId() != null && roleInGroup.getScope().equals(RoleScope.API) && canManageApi(roleInGroup.getPermissions()));
            }
            return m.getRoleId() != null && roleInGroup.getScope().equals(RoleScope.API);
        }).map(MembershipEntity::getReferenceId).toArray(String[]::new);
        if (groupIds.length > 0 && groupIds[0] != null) {
            groupApis = apiRepository.search(queryToCriteria(apiQuery).groups(groupIds).build());
        }
        // get user subscribed apis, useful when an API becomes private and an app owner is not anymore in members.
        if (portal) {
            final Set<String> applications = applicationService.findByUser(userId).stream().map(ApplicationListItem::getId).collect(toSet());
            if (!applications.isEmpty()) {
                final SubscriptionQuery query = new SubscriptionQuery();
                query.setApplications(applications);
                final Collection<SubscriptionEntity> subscriptions = subscriptionService.search(query);
                if (subscriptions != null && !subscriptions.isEmpty()) {
                    subscribedApis = apiRepository.search(queryToCriteria(apiQuery).ids(subscriptions.stream().map(SubscriptionEntity::getApi).distinct().toArray(String[]::new)).build());
                }
            }
        }
    }
    List<Api> allApis = new ArrayList<>();
    allApis.addAll(publicApis);
    allApis.addAll(userApis);
    allApis.addAll(groupApis);
    allApis.addAll(subscribedApis);
    return allApis.stream().distinct().collect(toList());
}