Ejemplo n.º 1
0
 /**
  * Gets a node's default vanity URL for the given locale and workspace. If none is default then
  * take the first mapping for the locale.
  *
  * @param contentNode the content node for which to return a mapping
  * @param workspace the workspace to look for mappings
  * @param locale the locale to which the mapping should apply
  * @param siteKey
  * @return the VanityUrl bean
  * @throws RepositoryException if there was an unexpected exception accessing the repository
  */
 public VanityUrl getVanityUrlForWorkspaceAndLocale(
     final JCRNodeWrapper contentNode, String workspace, Locale locale, final String siteKey)
     throws RepositoryException {
   return JCRTemplate.getInstance()
       .doExecuteWithSystemSession(
           null,
           workspace,
           locale,
           new JCRCallback<VanityUrl>() {
             public VanityUrl doInJCR(JCRSessionWrapper session) throws RepositoryException {
               return vanityUrlManager.getVanityUrlForCurrentLocale(contentNode, siteKey, session);
             }
           });
 }
Ejemplo n.º 2
0
 /**
  * Add or update a vanity URL mapping for a specific content node and the language code set in the
  * VanityUrl bean.
  *
  * <p>If the URL mapping has already been saved before we check whether the default and active
  * flag in the bean is different to the saved one, so we do an update, otherwise no operation is
  * done.
  *
  * <p>If the new or updated mapping is now the default one for the language, then we also check if
  * there already is another default URL for this language and set its default flag to false.
  *
  * <p>We also check whether the same URL is already existing for a different node or language in
  * the current site and throw a ConstraintViolationException if this is the case.
  *
  * @param contentNode the content node for which to add the given mapping
  * @param vanityUrl the VanityUrl bean representing the URL to be added
  * @return true if the vanity URL was added or false if it was not added
  * @throws ConstraintViolationException if the vanity URL mapping already exists for a different
  *     content node or language in the site
  * @throws RepositoryException if there was an unexpected exception accessing the repository
  */
 public boolean saveVanityUrlMapping(final JCRNodeWrapper contentNode, final VanityUrl vanityUrl)
     throws RepositoryException {
   cacheByUrl.flush();
   return JCRTemplate.getInstance()
       .doExecuteWithSystemSession(
           new JCRCallback<Boolean>() {
             public Boolean doInJCR(JCRSessionWrapper session) throws RepositoryException {
               JCRNodeWrapper currentContentNode =
                   session.getNodeByUUID(contentNode.getIdentifier());
               return vanityUrlManager.saveVanityUrlMapping(
                   currentContentNode, vanityUrl, session);
             }
           });
 }
Ejemplo n.º 3
0
 /**
  * Find any mappings for the given vanity URL. If a site is specified the query will be done only
  * for the specified site, otherwise all sites in the workspace will be searched through and a
  * list of VanityURL beans will be returned. The method searches mappings in any language.
  *
  * @param url URL path to check whether there is a content mapping for it (URL must start with /)
  * @param site key of the site to search for the mapping or all sites if the string is null or
  *     empty
  * @param workspace the workspace to look for mappings
  * @return the list of VanityUrl beans
  * @throws RepositoryException if there was an unexpected exception accessing the repository
  */
 public List<VanityUrl> findExistingVanityUrls(
     final String url, final String site, final String workspace) throws RepositoryException {
   final String cacheKey = getCacheByUrlKey(url, site, workspace);
   if (cacheByUrl.containsKey(cacheKey)) {
     return (List<VanityUrl>) cacheByUrl.get(cacheKey);
   }
   return JCRTemplate.getInstance()
       .doExecuteWithSystemSession(
           null,
           workspace,
           new JCRCallback<List<VanityUrl>>() {
             public List<VanityUrl> doInJCR(JCRSessionWrapper session) throws RepositoryException {
               List<VanityUrl> vanityUrls =
                   vanityUrlManager.findExistingVanityUrls(url, site, session);
               cacheByUrl.put(cacheKey, vanityUrls);
               return vanityUrls;
             }
           });
 }
Ejemplo n.º 4
0
  public Collection<Message> produce(final Execution execution) {
    final Map<String, Object> vars = ((ExecutionImpl) execution).getVariables();
    Locale locale = (Locale) vars.get("locale");

    if (templateKey != null) {
      MailTemplate template = null;
      MailTemplateRegistry templateRegistry =
          ((ProcessEngine) SpringContextSingleton.getBean("processEngine"))
              .get(MailTemplateRegistry.class);
      if (locale != null) {
        template = (templateRegistry.getTemplate(templateKey + "." + locale.toString()));
        if (template == null) {
          template = (templateRegistry.getTemplate(templateKey + "." + locale.getLanguage()));
        }
      }
      if (template == null) {
        template = templateRegistry.getTemplate(templateKey);
      }
      setTemplate(template);
    }

    if (ServicesRegistry.getInstance().getMailService().isEnabled() && getTemplate() != null) {
      try {
        return JCRTemplate.getInstance()
            .doExecuteWithSystemSession(
                null,
                "default",
                locale,
                new JCRCallback<Collection<Message>>() {
                  public Collection<Message> doInJCR(JCRSessionWrapper session)
                      throws RepositoryException {
                    try {
                      scriptEngine =
                          ScriptEngineUtils.getInstance()
                              .getEngineByName(getTemplate().getLanguage());
                      bindings = null;
                      Message email = instantiateEmail();
                      fillFrom(email, execution, session);
                      fillRecipients(email, execution, session);
                      fillSubject(email, execution, session);
                      fillContent(email, execution, session);
                      Address[] addresses = email.getRecipients(Message.RecipientType.TO);
                      if (addresses != null && addresses.length > 0) {
                        return Collections.singleton(email);
                      } else {
                        return Collections.emptyList();
                      }
                    } catch (MessagingException e) {
                      logger.error(e.getMessage(), e);
                    } catch (ScriptException e) {
                      logger.error(e.getMessage(), e);
                    }
                    return Collections.emptyList();
                  }
                });
      } catch (RepositoryException e) {
        logger.error(e.getMessage(), e);
      }
    }
    return Collections.emptyList();
  }