Java Examples for com.day.cq.tagging.Tag

@Override
public com.day.cq.tagging.Tag[] getTags() {
    if (tagCache != null)
        return tagCache;
    Resource contentResource = getContentResource();
    TagManager tagManager = contentResource.getResourceResolver().adaptTo(TagManager.class);
    tagCache = tagManager == null ? new Tag[0] : tagManager.getTags(contentResource);
    return tagCache;
}

/**
     * Work flow execute method *
     */
@Override
public void execute(WorkItem workItem, WorkflowSession workflowSession, MetaDataMap args) throws WorkflowException {
    boolean useUpstream = true;
    boolean useDownstream = true;
    final WorkflowData workflowData = workItem.getWorkflowData();
    final String type = workflowData.getPayloadType();
    // Check if the payload is a path in the JCR
    if (!StringUtils.equals(type, "JCR_PATH")) {
        return;
    }
    Session session = workflowSession.getSession();
    // Get the path to the JCR resource from the payload
    String path = workflowData.getPayload().toString();
    // Get a ResourceResolver using the same permission set as the Workflow's executing Session
    ResourceResolver resolver = null;
    Map<String, Object> authInfo = new HashMap<String, Object>();
    authInfo.put(JcrResourceConstants.AUTHENTICATION_INFO_SESSION, session);
    // Initialize some variables
    List<String> newTagTitles = new ArrayList<String>();
    List<String> newUpstreamTagTitles = new ArrayList<String>();
    List<String> newDownstreamTagTitles = new ArrayList<String>();
    Locale locale = null;
    try {
        // Get the Workflow Sessions' resource resolver using the authInfo created above
        resolver = resourceResolverFactory.getResourceResolver(authInfo);
        // Get the Resource representing the WF payload
        final Resource resource = resolver.getResource(path);
        // Get the TagManager (using the same permission level as the Workflow's Session)
        final TagManager tagManager = resolver.adaptTo(TagManager.class);
        // Use custom implementation to find the resource to look for cq:tags and write the
        // custom property "tag-titles" to
        final Resource contentResource = getContentResource(resource);
        if (contentResource == null) {
            log.error("Could not find a valid content resource node for payload: {}", resource.getPath());
            return;
        }
        // Gain access to the content resournce's properties
        final ValueMap properties = contentResource.adaptTo(ValueMap.class);
        // Get the full tag paths (namespace:path/to/tag) from the content resource
        // This only works on the cq:tags property
        final Tag[] tags = tagManager.getTags(contentResource);
        // Get any previously applied Localized Tag Titles.
        // This is used to determine if changes if any updates are needed to this node.
        final String[] previousTagTitles = properties.get(PROPERTY_TAG_TITLES, new String[] {});
        if (!ArrayUtils.isEmpty(tags)) {
            // Derive the locale
            if (DamUtil.isAsset(resource)) {
                // Dam assets use path segments to derive the locale (/content/dam/us/en/...)
                locale = getLocaleFromPath(resource);
            } else {
                // Page's use the jcr:language property accessed via the CQ Page API
                Page page = resource.adaptTo(Page.class);
                if (page != null) {
                    locale = page.getLanguage(true);
                }
            }
            // This does not remove duplicate titles (different tag trees could repeat titles)
            if (useUpstream) {
                newUpstreamTagTitles = tagsToUpstreamLocalizedTagTitles(tags, locale, tagManager);
                newTagTitles.addAll(newUpstreamTagTitles);
            }
            if (useDownstream) {
                newDownstreamTagTitles = tagsToDownstreamLocalizedTagTitles(tags, locale, tagManager, new ArrayList<String>(), 0);
                newTagTitles.addAll(newDownstreamTagTitles);
            }
            if (!useUpstream && !useDownstream) {
                newTagTitles.addAll(tagsToLocalizedTagTitles(tags, locale));
            }
        }
        try {
            // Get the node in the JCR the payload points to
            final Node node = session.getNode(contentResource.getPath());
            // If the currently applied Tag Titles are the same as the derived Tag titles then skip!
            if (!isSame(newTagTitles.toArray(new String[] {}), previousTagTitles)) {
                // If changes have been made to the Tag Names, then apply to the tag-titles property
                // on the content resource.
                node.setProperty(PROPERTY_TAG_TITLES, newUpstreamTagTitles.toArray(new String[newUpstreamTagTitles.size()]));
            } else {
                log.debug("No change in Tag Titles. Do not update this content resource.");
            }
        } catch (PathNotFoundException ex) {
            log.error(ex.getMessage());
        } catch (RepositoryException ex) {
            log.error(ex.getMessage());
        }
    } catch (LoginException ex) {
        log.error(ex.getMessage());
    } finally {
        // Clean up after yourself please!!!
        if (resolver != null) {
            resolver.close();
            resolver = null;
        }
    }
}

@Override
protected final void doPost(SlingHttpServletRequest request, SlingHttpServletResponse response) throws ServletException, IOException {
    response.setContentType("application/json");
    response.setCharacterEncoding("UTF-8");
    final JSONObject jsonResponse = new JSONObject();
    final TagManager tagManager = request.getResourceResolver().adaptTo(TagManager.class);
    final RequestParameter charsetParam = request.getRequestParameter("charset");
    final RequestParameter cleanParam = request.getRequestParameter("clean");
    final RequestParameter delimiterParam = request.getRequestParameter("delimiter");
    final RequestParameter fileParameter = request.getRequestParameter("file");
    final RequestParameter separatorParam = request.getRequestParameter("separator");
    final RequestParameter converterParam = request.getRequestParameter("converter");
    final RequestParameter fallbackConverterParam = request.getRequestParameter("fallbackConverter");
    boolean clean = DEFAULT_CLEAN;
    if (cleanParam != null) {
        clean = Boolean.valueOf(StringUtils.defaultIfEmpty(cleanParam.toString(), String.valueOf(DEFAULT_CLEAN)));
    }
    String converter = DEFAULT_CONVERTER;
    if (converterParam != null) {
        converter = StringUtils.defaultIfEmpty(converterParam.toString(), DEFAULT_CONVERTER);
    }
    String fallbackConverter = NONE_CONVERTER;
    if (fallbackConverterParam != null) {
        fallbackConverter = StringUtils.defaultIfEmpty(fallbackConverterParam.toString(), NONE_CONVERTER);
    }
    String charset = DEFAULT_CHARSET;
    if (charsetParam != null) {
        charset = StringUtils.defaultIfEmpty(charsetParam.toString(), DEFAULT_CHARSET);
    }
    Character delimiter = null;
    if (delimiterParam != null && StringUtils.isNotBlank(delimiterParam.toString())) {
        delimiter = delimiterParam.toString().charAt(0);
    }
    Character separator = null;
    if (separatorParam != null && StringUtils.isNotBlank(separatorParam.toString())) {
        separator = separatorParam.toString().charAt(0);
    }
    final List<TagDataConverter> tagDataConverters = new ArrayList<TagDataConverter>();
    final TagDataConverter primaryTagConverter = this.getTagDataConverter(converter);
    if (primaryTagConverter != null) {
        tagDataConverters.add(primaryTagConverter);
    }
    final TagDataConverter fallbackTagConverter = this.getTagDataConverter(fallbackConverter);
    if (fallbackTagConverter != null) {
        tagDataConverters.add(fallbackTagConverter);
    }
    if (tagDataConverters.isEmpty()) {
        log.error("Could not find Tag Data Converter [ {} ]", converter);
        response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    } else if (fileParameter != null && fileParameter.getInputStream() != null) {
        InputStream is = fileParameter.getInputStream();
        final Csv csv = new Csv();
        if (delimiter != null) {
            log.debug("Setting Field Delimiter to [ {} ]", delimiter);
            csv.setFieldDelimiter(delimiter);
        }
        if (separator != null) {
            log.debug("Setting Field Separator to [ {} ]", separator);
            csv.setFieldSeparatorRead(separator);
        }
        if (clean) {
            is = this.stripLineEnds(is, charset, csv.getFieldSeparatorRead());
        }
        final Iterator<String[]> rows = csv.read(is, charset);
        try {
            request.getResourceResolver().adaptTo(Session.class).getWorkspace().getObservationManager().setUserData("acs-aem-tools.tag-maker");
            final List<String> result = this.makeTags(tagManager, tagDataConverters, rows);
            try {
                jsonResponse.put("tagIds", result);
            } catch (JSONException e) {
                log.error("Could not serialized Tag Maker results into JSON", e);
            }
            this.addMessage(jsonResponse, result.size() + " tags were processed");
        } catch (InvalidTagFormatException e) {
            log.error("Could not create Tag due to illegal formatting", e);
            this.addMessage(jsonResponse, "Could not create tags due to illegal formatting");
            response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        } catch (RepositoryException e) {
            log.error("Could not save Tags to JCR", e);
            this.addMessage(jsonResponse, "Could not save tags");
            response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    } else {
        log.error("Could not find CSV file in request.");
        this.addMessage(jsonResponse, "CSV file is missing");
        response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    }
    response.getWriter().print(jsonResponse.toString());
}

@Override
public Tag[] getTags() {
    return new Tag[0];
}