/**
   * Create a data group
   *
   * @param doi
   * @param webAddress
   * @param title
   * @return
   */
  @POST
  @Authenticated
  @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
  @Produces(MediaType.APPLICATION_JSON)
  public Response mint(
      @FormParam("doi") String doi,
      @FormParam("webAddress") String webAddress,
      @FormParam("graph") String graph,
      @FormParam("title") String title,
      @FormParam("resourceType") String resourceTypeString,
      @FormParam("resourceTypesMinusDataset") Integer resourceTypesMinusDataset,
      @FormParam("finalCopy") @DefaultValue("false") Boolean finalCopy) {

    // If resourceType is specified by an integer, then use that to set the String resourceType.
    // If the user omits
    try {
      if (resourceTypesMinusDataset != null && resourceTypesMinusDataset > 0) {
        resourceTypeString = new ResourceTypes().get(resourceTypesMinusDataset).uri;
      }
    } catch (IndexOutOfBoundsException e) {
      throw new BadRequestException(
          "BCID System Unable to set resource type",
          "There was an error retrieving the resource type uri. Did you provide a valid resource type?");
    }

    if (resourceTypeString == null || resourceTypeString.isEmpty()) {
      throw new BadRequestException("ResourceType is required");
    }

    // Mint the Bcid
    if (title == null || title.isEmpty()) {
      title = resourceTypeString;
    }

    Bcid.BcidBuilder builder =
        new Bcid.BcidBuilder(resourceTypeString)
            .ezidRequest(Boolean.valueOf(settingsManager.retrieveValue("ezidRequests")))
            .doi(doi)
            .title(title)
            .graph(graph)
            .finalCopy(finalCopy);

    if (!StringUtils.isEmpty(webAddress)) {
      UriComponents webAddressComponents = UriComponentsBuilder.fromUriString(webAddress).build();
      builder.webAddress(webAddressComponents.toUri());
    }

    Bcid bcid = builder.build();
    bcidService.create(bcid, user.getUserId());

    // TODO return the bcid object here
    return Response.ok("{\"identifier\": \"" + bcid.getIdentifier() + "\"}").build();
  }
  @DELETE
  @RequireOrganizationAccess
  @JSONP
  @Produces({MediaType.APPLICATION_JSON, "application/javascript"})
  public ApiResponse executeDelete(
      @Context UriInfo ui,
      @QueryParam("callback") @DefaultValue("callback") String callback,
      @QueryParam("app_delete_confirm") String confirmDelete)
      throws Exception {

    if (!"confirm_delete_of_application_and_data".equals(confirmDelete)) {
      throw new IllegalArgumentException(
          "Cannot delete application without app_delete_confirm parameter");
    }

    Properties props = management.getProperties();

    // for now, only works in test mode
    String testProp = (String) props.get("usergrid.test");
    if (testProp == null || !Boolean.parseBoolean(testProp)) {
      throw new UnsupportedOperationException();
    }

    if (applicationId == null) {
      throw new IllegalArgumentException("Application ID not specified in request");
    }

    management.deleteApplication(applicationId);

    if (logger.isDebugEnabled()) {
      logger.debug("ApplicationResource.delete() deleted appId = {}", applicationId);
    }

    ApiResponse response = createApiResponse();
    response.setAction("delete");
    response.setApplication(emf.getEntityManager(applicationId).getApplication());
    response.setParams(ui.getQueryParameters());

    if (logger.isDebugEnabled()) {
      logger.debug("ApplicationResource.delete() sending response ");
    }

    return response;
  }
Beispiel #3
0
  private static Map<String, Object> makeClientData(
      final PwmApplication pwmApplication,
      final PwmSession pwmSession,
      final HttpServletRequest request,
      final HttpServletResponse response,
      final String pageUrl)
      throws ChaiUnavailableException, PwmUnrecoverableException {
    final Configuration config = pwmApplication.getConfig();
    final TreeMap<String, Object> settingMap = new TreeMap<>();
    settingMap.put(
        "client.ajaxTypingTimeout",
        Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_AJAX_TYPING_TIMEOUT)));
    settingMap.put(
        "client.ajaxTypingWait",
        Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_AJAX_TYPING_WAIT)));
    settingMap.put(
        "client.activityMaxEpsRate",
        Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_ACTIVITY_MAX_EPS_RATE)));
    settingMap.put(
        "client.js.enableHtml5Dialog",
        Boolean.parseBoolean(config.readAppProperty(AppProperty.CLIENT_JS_ENABLE_HTML5DIALOG)));
    settingMap.put(
        "client.pwShowRevertTimeout",
        Integer.parseInt(config.readAppProperty(AppProperty.CLIENT_PW_SHOW_REVERT_TIMEOUT)));
    settingMap.put(
        "enableIdleTimeout", config.readSettingAsBoolean(PwmSetting.DISPLAY_IDLE_TIMEOUT));
    settingMap.put(
        "pageLeaveNotice", config.readSettingAsLong(PwmSetting.SECURITY_PAGE_LEAVE_NOTICE_TIMEOUT));
    settingMap.put(
        "setting-showHidePasswordFields",
        pwmApplication
            .getConfig()
            .readSettingAsBoolean(
                password.pwm.config.PwmSetting.DISPLAY_SHOW_HIDE_PASSWORD_FIELDS));
    settingMap.put("setting-displayEula", PwmConstants.ENABLE_EULA_DISPLAY);
    settingMap.put(
        "setting-showStrengthMeter",
        config.readSettingAsBoolean(PwmSetting.PASSWORD_SHOW_STRENGTH_METER));

    {
      long idleSeconds = config.readSettingAsLong(PwmSetting.IDLE_TIMEOUT_SECONDS);
      if (pageUrl == null || pageUrl.isEmpty()) {
        LOGGER.warn(pwmSession, "request to /client data did not incliude pageUrl");
      } else {
        try {
          final PwmURL pwmURL = new PwmURL(new URI(pageUrl), request.getContextPath());
          final TimeDuration maxIdleTime =
              IdleTimeoutCalculator.idleTimeoutForRequest(pwmURL, pwmApplication, pwmSession);
          idleSeconds = maxIdleTime.getTotalSeconds();
        } catch (Exception e) {
          LOGGER.error(
              pwmSession, "error determining idle timeout time for request: " + e.getMessage());
        }
      }
      settingMap.put("MaxInactiveInterval", idleSeconds);
    }
    settingMap.put("paramName.locale", config.readAppProperty(AppProperty.HTTP_PARAM_NAME_LOCALE));
    settingMap.put("startupTime", pwmApplication.getStartupTime());
    settingMap.put("applicationMode", pwmApplication.getApplicationMode());

    final String contextPath = request.getContextPath();
    settingMap.put("url-context", contextPath);
    settingMap.put(
        "url-logout", contextPath + PwmServletDefinition.Logout.servletUrl() + "?idle=true");
    settingMap.put("url-command", contextPath + PwmServletDefinition.Command.servletUrl());
    settingMap.put(
        "url-resources",
        contextPath
            + "/public/resources"
            + pwmApplication.getResourceServletService().getResourceNonce());
    settingMap.put("url-restservice", contextPath + "/public/rest");

    {
      String passwordGuideText =
          pwmApplication
              .getConfig()
              .readSettingAsLocalizedString(
                  PwmSetting.DISPLAY_PASSWORD_GUIDE_TEXT,
                  pwmSession.getSessionStateBean().getLocale());
      final MacroMachine macroMachine =
          pwmSession.getSessionManager().getMacroMachine(pwmApplication);
      passwordGuideText = macroMachine.expandMacros(passwordGuideText);
      settingMap.put("passwordGuideText", passwordGuideText);
    }

    {
      final List<String> formTypeOptions = new ArrayList<>();
      for (final FormConfiguration.Type type : FormConfiguration.Type.values()) {
        formTypeOptions.add(type.toString());
      }
      settingMap.put("formTypeOptions", formTypeOptions);
    }

    {
      final List<String> actionTypeOptions = new ArrayList<>();
      for (final ActionConfiguration.Type type : ActionConfiguration.Type.values()) {
        actionTypeOptions.add(type.toString());
      }
      settingMap.put("actionTypeOptions", actionTypeOptions);
    }

    {
      final List<String> epsTypes = new ArrayList<>();
      for (final Statistic.EpsType loopEpsType : Statistic.EpsType.values()) {
        epsTypes.add(loopEpsType.toString());
      }
      settingMap.put("epsTypes", epsTypes);
    }

    {
      final List<String> epsDurations = new ArrayList<>();
      for (final Statistic.EpsDuration loopEpsDuration : Statistic.EpsDuration.values()) {
        epsDurations.add(loopEpsDuration.toString());
      }
      settingMap.put("epsDurations", epsDurations);
    }

    {
      final Map<String, String> localeInfo = new TreeMap<>();
      final Map<String, String> localeDisplayNames = new TreeMap<>();
      final Map<String, String> localeFlags = new TreeMap<>();

      for (final Locale locale : pwmApplication.getConfig().getKnownLocales()) {
        final String flagCode = pwmApplication.getConfig().getKnownLocaleFlagMap().get(locale);
        localeFlags.put(locale.toString(), flagCode);
        localeInfo.put(
            locale.toString(), locale.getDisplayName() + " - " + locale.getDisplayLanguage(locale));
        localeDisplayNames.put(locale.toString(), locale.getDisplayLanguage());
      }

      settingMap.put("localeInfo", localeInfo);
      settingMap.put("localeDisplayNames", localeDisplayNames);
      settingMap.put("localeFlags", localeFlags);
      settingMap.put("defaultLocale", PwmConstants.DEFAULT_LOCALE.toString());
    }

    if (pwmApplication
            .getConfig()
            .readSettingAsEnum(PwmSetting.LDAP_SELECTABLE_CONTEXT_MODE, SelectableContextMode.class)
        != SelectableContextMode.NONE) {
      final Map<String, Map<String, String>> ldapProfiles = new LinkedHashMap<>();
      for (final String ldapProfile : pwmApplication.getConfig().getLdapProfiles().keySet()) {
        final Map<String, String> contexts =
            pwmApplication.getConfig().getLdapProfiles().get(ldapProfile).getLoginContexts();
        ldapProfiles.put(ldapProfile, contexts);
      }
      settingMap.put("ldapProfiles", ldapProfiles);
    }

    return settingMap;
  }