@Override
  public void init() throws Exception {
    super.init();

    if (this.accountModelFactory == null) {
      this.accountModelFactory = new DefaultAccountModelFactory();
    }
    if (this.accountStoreModelFactory == null) {
      this.accountStoreModelFactory = new ExternalAccountStoreModelFactory();
    }
    if (this.errorModelFactory == null) {
      this.errorModelFactory = new RegisterErrorModelFactory(this.messageSource);
    }

    Assert.notNull(this.client, "client cannot be null.");
    Assert.notNull(this.authenticationResultSaver, "authenticationResultSaver cannot be null.");
    Assert.hasText(this.loginUri, "loginUri cannot be null or empty.");
    Assert.hasText(this.verifyViewName, "verifyViewName cannot be null or empty.");
    Assert.notNull(this.preRegisterHandler, "preRegisterHandler cannot be null.");
    Assert.notNull(this.postRegisterHandler, "postRegisterHandler cannot be null.");
    Assert.notNull(this.accountModelFactory, "accountModelFactory cannot be null.");
    Assert.notNull(this.accountStoreModelFactory, "accountStoreModelFactory cannot be null.");
    Assert.notNull(this.errorModelFactory, "errorModelFactory cannot be null.");
    Assert.notNull(this.accountStoreResolver, "accountStoreResolver cannot be null.");
  }
 /**
  * Creates a new instance.
  *
  * @param nonceCache a cache to place used CSRF tokens. This is required to ensure the consumed
  *     token is never used again, which is mandatory for CSRF protection. This cache <em>MUST</em>
  *     have a TTL value equal to or greater than {@code ttlMillis}. Cache key: a unique token ID,
  *     Cache value: the used token
  * @param signingKey a base64-encoded (and hopefully secure-random) cryptographic signing key used
  *     to digitally sign the CSRF token to ensure it cannot be tampered with by HTTP clients.
  * @param ttlMillis the length of time in milliseconds for which a generated CSRF token is valid.
  *     When a token is created, it cannot be used after this duration, even if it has not been
  *     consumed yet.
  */
 public CacheCsrfTokenRepository(Cache nonceCache, String signingKey, long ttlMillis) {
   Assert.notNull(nonceCache, "nonce cache cannot be null.");
   this.nonceCache = nonceCache;
   Assert.hasText(signingKey, "signingKey cannot be null or empty.");
   this.signingKey = signingKey;
   Assert.isTrue(ttlMillis > 0, "ttlMillis must be greater than zero.");
   this.ttlMillis = ttlMillis;
 }
 public SpringSpaController(
     Controller delegate, String jsonView, List<MediaType> producesMediaTypes) {
   Assert.notNull(delegate, "Delegate controller cannot be null.");
   Assert.notEmpty(producesMediaTypes, "produced media types cannot be null or empty.");
   Assert.hasText(jsonView, "jsonView cannot be null or empty.");
   this.delegate = delegate;
   this.jsonView = jsonView;
   this.producesMediaTypes = producesMediaTypes;
 }
  public DefaultIdSiteCallbackHandler(
      InternalDataStore dataStore, Application application, Object httpRequest) {
    Assert.notNull(dataStore, "datastore cannot be null or empty.");
    Assert.notNull(application, "application cannot be null.");
    Assert.notNull(httpRequest, "httpRequest cannot be null.");

    this.dataStore = dataStore;
    this.application = application;
    this.jwtResponse = getJwtResponse(httpRequest);
    this.nonceStore = new DefaultNonceStore(dataStore.getCacheResolver());
  }
 protected DefaultCriteria(O options) {
   Assert.notNull(options, "options argument cannot be null.");
   Assert.isInstanceOf(
       Expandable.class,
       options,
       "options argument is expected to implement the "
           + Expandable.class.getName()
           + " interface.");
   this.options = options;
   this.criterionEntries = new ArrayList<Criterion>();
   this.orderEntries = new ArrayList<Order>();
 }
 @Override
 public CreatePhoneRequestBuilder withResponseOptions(PhoneOptions options)
     throws IllegalArgumentException {
   Assert.notNull(options, "options can't be null.");
   this.options = options;
   return this;
 }
 public void init() {
   super.init();
   Assert.notNull(serverUriResolver, "serverUriResolver must be configured.");
   IdSiteController controller = new LogoutIdSiteController();
   controller.setServerUriResolver(serverUriResolver);
   controller.setCallbackUri(idSiteResultUri);
   controller.init();
   this.idSiteController = controller;
 }
 /* @since 1.0.RC5 */
 private Error constructError(Map jsonMap) {
   Assert.isTrue(isError(jsonMap));
   Map<String, Object> errorMap = getRequiredValue(jsonMap, ERROR);
   Error error =
       new DefaultErrorBuilder((Integer) getRequiredValue(errorMap, STATUS))
           .code((Integer) getRequiredValue(errorMap, "code"))
           .developerMessage((String) getRequiredValue(errorMap, "developerMessage"))
           .message((String) getRequiredValue(errorMap, "message"))
           .moreInfo((String) getRequiredValue(errorMap, "moreInfo"))
           .build();
   return error;
 }
 /**
  * Ensures the message used for the exception (i.e. exception.getMessage()) reports the {@code
  * developerMessage} returned by the Stormpath API Server. The regular Stormpath response body
  * {@code message} field is targeted at applicadtion end-users that could very likely be
  * non-technical. Since an exception should be helpful to developers, it is better to show a more
  * technical message.
  *
  * <p>Added as a fix for <a href="https://github.com/stormpath/stormpath-sdk-java/issues/28">Issue
  * #28</a>.
  *
  * @param error the response Error. Cannot be null.
  * @return {@code error.getDeveloperMessage()}
  * @since 0.9.2
  */
 private static String buildExceptionMessage(Error error) {
   Assert.notNull(error, "Error argument cannot be null.");
   StringBuilder sb = new StringBuilder();
   sb.append("HTTP ")
       .append(error.getStatus())
       .append(", Stormpath ")
       .append(error.getCode())
       .append(" (")
       .append(error.getMoreInfo())
       .append("): ")
       .append(error.getDeveloperMessage());
   return sb.toString();
 }
  private String getJwtResponse(Object httpRequestObject) {
    String jwtResponse;

    if (HttpRequest.class.isAssignableFrom(httpRequestObject.getClass())) {

      HttpRequest httpRequest = (HttpRequest) httpRequestObject;

      Assert.isTrue(
          httpRequest.getMethod() == HttpMethod.GET, "Only Http GET method is supported.");

      jwtResponse = httpRequest.getParameter(JWT_RESPONSE);

    } else {
      // This must never happen, if the object request is of HttpServletRequest type the
      // HTTP_SERVLET_REQUEST_WRAPPER_CLASS
      // must be already loaded and therefore cannot be null.
      if (HTTP_SERVLET_REQUEST_WRAPPER_CLASS == null) {
        throw new RuntimeException(
            "DefaultHttpServletRequestWrapper not loaded error occurred while handling httpRequest of type: "
                + httpRequestObject.getClass().getName());
      }

      Constructor<? extends HttpServletRequestWrapper> ctor =
          Classes.getConstructor(HTTP_SERVLET_REQUEST_WRAPPER_CLASS, Object.class);

      HttpServletRequestWrapper httpServletRequestWrapper =
          Classes.instantiate(ctor, httpRequestObject);
      HttpMethod method = HttpMethod.fromName(httpServletRequestWrapper.getMethod());
      Assert.isTrue(HttpMethod.GET == method, "Only Http GET method is supported.");

      jwtResponse = httpServletRequestWrapper.getParameter(JWT_RESPONSE);
    }

    if (!Strings.hasText(jwtResponse)) {
      throw new InvalidJwtException(InvalidJwtException.JWT_REQUIRED_ERROR);
    }
    return jwtResponse;
  }
  // since 0.9.2
  private Object toMapValue(
      final AbstractResource resource, final String propName, Object value, boolean partialUpdate) {
    if (resource instanceof CustomData) {
      // no sanitization: CustomData resources retain their values as-is:
      return value;
    }

    if (value instanceof CustomData || value instanceof ProviderData || value instanceof Provider) {
      if (partialUpdate) {
        Assert.isInstanceOf(AbstractResource.class, value);

        AbstractResource abstractResource = (AbstractResource) value;
        Set<String> updatedPropertyNames = abstractResource.getUpdatedPropertyNames();

        LinkedHashMap<String, Object> properties =
            new LinkedHashMap<String, Object>(Collections.size(updatedPropertyNames));

        for (String updatedCustomPropertyName : updatedPropertyNames) {
          Object object = abstractResource.getProperty(updatedCustomPropertyName);
          properties.put(updatedCustomPropertyName, object);
        }

        value = properties;
      }

      return value;
    }

    if (value instanceof Map) {
      // Since defaultModel is a map, the DataStore thinks it is a Resource. This causes the code to
      // crash later one as Resources
      // do need to have an href property
      if (resource instanceof ModeledEmailTemplate && propName.equals("defaultModel")) {
        return value;
      } else {
        // if the property is a reference, don't write the entire object - just the href will do:
        // TODO need to change this to write the entire object because this code defeats the purpose
        // of entity expansion
        //     when this code gets called (returning the reference instead of the whole object that
        // is returned from Stormpath)
        return this.referenceFactory.createReference(propName, (Map) value);
      }
    }

    if (value instanceof Resource) {
      return this.referenceFactory.createReference(propName, (Resource) value);
    }

    return value;
  }
 public T add(Criterion criterion) {
   Assert.notNull(criterion, "criterion cannot be null.");
   this.criterionEntries.add(criterion);
   return (T) this;
 }
示例#13
0
 /**
  * Sorts the given list of {@code MimeType} objects by specificity.
  *
  * <p>Given two mime types:
  *
  * <ol>
  *   <li>if either mime type has a {@linkplain MimeType#isWildcardType() wildcard type}, then the
  *       mime type without the wildcard is ordered before the other.
  *   <li>if the two mime types have different {@linkplain MimeType#getType() types}, then they are
  *       considered equal and remain their current order.
  *   <li>if either mime type has a {@linkplain MimeType#isWildcardSubtype() wildcard subtype} ,
  *       then the mime type without the wildcard is sorted before the other.
  *   <li>if the two mime types have different {@linkplain MimeType#getSubtype() subtypes}, then
  *       they are considered equal and remain their current order.
  *   <li>if the two mime types have a different amount of {@linkplain
  *       MimeType#getParameter(String) parameters}, then the mime type with the most parameters is
  *       ordered before the other.
  * </ol>
  *
  * <p>For example:
  *
  * <blockquote>
  *
  * audio/basic &lt; audio/* &lt; *&#047;*
  *
  * </blockquote>
  *
  * <blockquote>
  *
  * audio/basic;level=1 &lt; audio/basic
  *
  * </blockquote>
  *
  * <blockquote>
  *
  * audio/basic == text/html
  *
  * </blockquote>
  *
  * <blockquote>
  *
  * audio/basic == audio/wave
  *
  * </blockquote>
  *
  * @param mimeTypes the list of mime types to be sorted
  * @see <a href="http://tools.ietf.org/html/rfc7231#section-5.3.2">HTTP 1.1: Semantics and
  *     Content, section 5.3.2</a>
  */
 public static void sortBySpecificity(List<MimeType> mimeTypes) {
   Assert.notNull(mimeTypes, "'mimeTypes' must not be null");
   if (mimeTypes.size() > 1) {
     Collections.sort(mimeTypes, SPECIFICITY_COMPARATOR);
   }
 }
 public DefaultResourceConverter(ReferenceFactory referenceFactory) {
   Assert.notNull(referenceFactory, "referenceFactory cannot be null.");
   this.referenceFactory = referenceFactory;
 }
 private int ensureOrderIndex() {
   int i = this.currentOrderIndex;
   Assert.state(
       i >= 0, "There is no current orderBy clause to declare as ascending or descending!");
   return i;
 }
 @Override
 public Map<String, Object> convert(AbstractResource resource) {
   Assert.notNull(resource, "resource cannot be null.");
   return toMap(resource, true);
 }
 public AuthenticationResultSaver(List<Saver<AuthenticationResult>> savers) {
   Assert.notEmpty(savers, "At least one Saver<AuthenticationResult> must be specified.");
   this.savers = Collections.unmodifiableList(savers);
 }
 /* @since 1.0.RC5 */
 private boolean isError(Map jsonMap) {
   Assert.notNull(jsonMap, "jsonMap cannot be null.");
   Object error = getOptionalValue(jsonMap, ERROR);
   return error != null;
 }
 public T add(Order order) {
   Assert.notNull(order, "order cannot be null.");
   this.orderEntries.add(order);
   this.currentOrderIndex = this.orderEntries.size() - 1;
   return (T) this;
 }
 @Override
 public IdSiteCallbackHandler setNonceStore(NonceStore nonceStore) {
   Assert.notNull(nonceStore);
   this.nonceStore = nonceStore;
   return this;
 }
 public DefaultCreatePhoneRequestBuilder(Phone phone) {
   Assert.notNull(phone, "Phone can't be null.");
   this.phone = phone;
 }