import com.day.cq.tagging.TagManager; //导入依赖的package包/类
private void populateTagListItems() {
    listItems = new ArrayList<>();
    String[] tags = properties.get(PN_TAGS, new String[0]);
    boolean matchAny = properties.get(PN_TAGS_MATCH, TAGS_MATCH_ANY_VALUE).equals(TAGS_MATCH_ANY_VALUE);
    if (ArrayUtils.isNotEmpty(tags)) {
        Page rootPage = getRootPage(PN_TAGS_PARENT_PAGE);
        if (rootPage != null) {
            TagManager tagManager = resourceResolver.adaptTo(TagManager.class);
            if (tagManager != null) {
                RangeIterator<Resource> resourceRangeIterator = tagManager.find(rootPage.getPath(), tags, matchAny);
                if (resourceRangeIterator != null) {
                    while (resourceRangeIterator.hasNext()) {
                        Page containingPage = pageManager.getContainingPage(resourceRangeIterator.next());
                        if (containingPage != null) {
                            listItems.add(containingPage);
                        }
                    }
                }
            }
        }
    }
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
private void createTag(TagDefinition tagDefinition, TagManager tagManager) {
    ReportRowSatus status;
    try {
        if (tagManager.resolve(tagDefinition.getId()) == null) {
            status = ReportRowSatus.CREATED;
        } else {
            status = ReportRowSatus.UPDATED_EXISTING;
        }

        final Tag tag = tagManager.createTag(
                tagDefinition.getId(),
                tagDefinition.getTitle(),
                tagDefinition.getDescription(),
                false);
        if (tag != null) {
            setTitles(tag, tagDefinition);
            record(status, tag.getTagID(), tag.getPath(), tag.getTitle());
            log.debug("Created tag [ {} -> {} ]", tagDefinition.getId(), tagDefinition.getTitle());
        } else {
            log.error("Tag [ {} ] is null", tagDefinition.getId());
        }
    } catch (Exception e) {
        record(ReportRowSatus.FAILED_TO_CREATE, tagDefinition.getId(), tagDefinition.getPath(), tagDefinition.getTitle());
        log.error("Unable to create tag [ {} -> {} ]", tagDefinition.getId(), tagDefinition.getTitle());
    }
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
public Tag findTag(String tagId, Asset asset, Session session) {
	Tag tag = null;
	ResourceResolver resourceResolver = null;

	try {
		resourceResolver = getResourceResolver(session);
		TagManager tagManager = resourceResolver.adaptTo(TagManager.class);
		tag = tagManager.resolve(tagId);
	} finally {
		if (null != resourceResolver && resourceResolver.isLive()) {
			resourceResolver.close();
		}
	}

	return tag;
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@PostConstruct
public void init() throws SlingModelsException {

    final Resource authorResource =
        resource.getResourceResolver().resolve(authorRef + "/profile");
    final GeometrixxMediaAuthorSummary authorSummary =
        authorResource.adaptTo(GeometrixxMediaAuthorSummary.class);

    final TagManager tagManager = resource.getResourceResolver().adaptTo(TagManager.class);

    id = resource.getParent().getPath();
    url = id + ".html";
    author = authorSummary != null ? authorSummary : new GeometrixxMediaAuthorSummary();
    body = articleBody != null ? articleBody : new GeometrixxMediaArticleBody("");
    tags = tagManager.getTags(resource);

}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@Override
public String getValue(Object result) {
  
  Resource resource = (Resource) result;
  
  TagManager tagMgr = resource.getResourceResolver().adaptTo(TagManager.class);

  log.debug("Loading tags from {}@{}", new String[] { resource.getPath(), property });
  List<String> tags = new ArrayList<String>();
  String[] values = resource.getValueMap().get(property, String[].class);
  if (values != null) {
    for (String value : values) {
      tags.add(tagMgr.resolve(value).getTitle());
    }
  }
  log.debug("Loaded {} tags", tags);

  return StringUtils.join(tags,";");
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
public List<Tag> getTags() {

    TagManager tagMgr = request.getResourceResolver().adaptTo(TagManager.class);

    Resource resource = (Resource) request.getAttribute("result");

    log.debug("Loading tags from {}@{}", new String[] { resource.getPath(), property });
    List<Tag> tags = new ArrayList<Tag>();
    String[] values = resource.getValueMap().get(property, String[].class);
    if (values != null) {
      for (String value : values) {
        tags.add(tagMgr.resolve(value));
      }
    }
    log.debug("Loaded {} tags", tags.size());

    return tags;

  }
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@Before
public void init() {
  log.info("init");
  
  MockitoAnnotations.initMocks(this);

  Map<String, Object> properties = new HashMap<String, Object>();
  properties.put("tags", TAGS_VALUE);

  when(request.getAttribute("result")).thenReturn(mockResource);
  when(mockResource.getValueMap()).thenReturn(new ValueMapDecorator(properties));

  when(request.getResourceResolver()).thenReturn(resolver);
  when(resolver.adaptTo(TagManager.class)).thenReturn(tagMgr);

  when(tagMgr.resolve(TAGS_VALUE[0])).thenReturn(tag1);
  when(tagMgr.resolve(TAGS_VALUE[1])).thenReturn(tag2);

  when(tag1.getTitle()).thenReturn(TAGS_VALUE[0]);
  when(tag2.getTitle()).thenReturn(TAGS_VALUE[1]);
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@Before
public void init() {
  log.info("init");
  
  MockitoAnnotations.initMocks(this);

  Map<String, Object> properties = new HashMap<String, Object>();
  properties.put("tags", TAGS_VALUE);
  when(mockResource.getValueMap()).thenReturn(new ValueMapDecorator(properties));

  when(mockResource.getResourceResolver()).thenReturn(resolver);
  when(resolver.adaptTo(TagManager.class)).thenReturn(tagMgr);

  when(tagMgr.resolve(TAGS_VALUE[0])).thenReturn(tag1);
  when(tagMgr.resolve(TAGS_VALUE[1])).thenReturn(tag2);

  when(tag1.getTitle()).thenReturn(TAGS_VALUE[0]);
  when(tag2.getTitle()).thenReturn(TAGS_VALUE[1]);
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
/**
 * Get keywords from a page.
 *
 * @param pageContent This is a map of page content
 * @param tm This is a Tag Manager instance
 * @return keywords This is the meta keywords set on the page
 */
public static String getKeywords(Map<String, Object> pageContent, TagManager tm) {
    String keywords = "";
    if (pageContent.get("cq:tags") != null) {
        ArrayList<?> tags = (ArrayList<?>) pageContent.get("cq:tags");
        if (tags != null) {
            for (Object obj : tags) {
                String value = obj.toString();
                if (keywords != null && keywords.length() > 0) {
                    keywords += ", ";
                }
                boolean noTagInfo = false;
                Tag tag = tm.resolve(value);
                if (tag != null) {
                    if (tag.getTitle() != null && tag.getTitle().length() > 0) {
                        value = tag.getTitle();
                    } else if (tag.getName() != null && tag.getName().length() > 0) {
                        value = tag.getName();
                    } else {
                        noTagInfo = true;
                    }
                } else {
                    noTagInfo = true;
                }
                if (noTagInfo) {
                    if (value != null && value.length() > 0) {
                        if (value.indexOf("/") != -1) {
                            value = StringUtils.substringAfter(value, "/");
                        } else if (value.indexOf(":") != -1) {
                            value = StringUtils.substringAfter(value, ":");
                        }
                    }
                }
                keywords += value;
            }
        }
    }
    return keywords;
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
public List<Tag> getTags() {
    List<Tag> tags = new ArrayList<Tag>();
    TagManager tagManager = resourceResolver.adaptTo(TagManager.class);

    if (contentFragment != null) {
        Object[] tagIds = (Object[]) contentFragment.getMetaData().get("cq:tags");
        if (tagIds != null) {
            for (Object cqTag : tagIds) {
                tags.add(tagManager.resolve(cqTag.toString()));
            }
        }
    }
    return tags;
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
/**
 * Perform the tag creation based on the successfully parsed values in parseTags(..).
 *
 * @param manager the action manager
 */
public void importTags(ActionManager manager) {
    tagDefinitions.values().stream().forEach(tagDefinition -> {
        try {
            manager.withResolver(rr -> {
                final TagManager tagManager = rr.adaptTo(TagManager.class);
                ReportRowSatus status;

                createTag(tagDefinition, tagManager);
            });
        } catch (Exception e) {
            log.error("Unable to import tags via ACS Commons MCP - Tag Creator", e);
        }
    });
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
protected static boolean hasTags(ResourceResolver rr, RequestParameter[] params) {
    if (params == null) {
        return false;
    } else {
        TagManager tagManager = rr.adaptTo(TagManager.class);
        return Stream.of(params).allMatch(param
                -> looksLikeTag(param.getString())
                && tagManager.resolve(param.getString()) != null
        );
    }
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
        throws ServletException, IOException {
    String root = request.getParameter(PN_PATH);
    if (StringUtils.isNotBlank(root)) {
        TagManager tagManager = request.getResourceResolver().adaptTo(TagManager.class);
        Tag rootTag = tagManager.resolve(root);
        // cannot resolve root tag
        if (null == rootTag) {
            response.sendError(SlingHttpServletResponse.SC_NOT_FOUND);
        } else {
            JSONArray items = new JSONArray();
            Iterator<Tag> children = rootTag.listChildren();
            Tag child = null;
            // iterate over child tags
            while(children.hasNext()) {
                child = children.next();
                try {
                    items.put((Object)new JSONObject()
                            .put(PN_KEY, child.getTitle())
                            .put(PN_VALUE, child.getDescription()));
                } catch (JSONException e) {
                    LOG.debug(e.getMessage());
                }
                child = null;
            }
            
            byte[] jsonBytes = items.toString().getBytes("UTF-8");

            response.setContentType("application/json");
            response.setCharacterEncoding("UTF-8");
            response.setContentLength(jsonBytes.length);
            response.getOutputStream().write(jsonBytes);
        }
    } else {
        response.sendError(SlingHttpServletResponse.SC_NOT_FOUND);
    }
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
/**
 * @param tagIDs
 * @return list of valid tags given array of IDs
 */
private List<Tag> getTags(final String[] tagIDs) {
    if (0 == ArrayUtils.getLength(tagIDs)) return Collections.emptyList(); 
    final TagManager tm = getResourceResolver().adaptTo(TagManager.class);
    List<Tag> tags = new ArrayList<Tag>();
    
    Tag tag = null;
    for(String id : tagIDs) {
        tag = tm.resolve(id);
        if (null != tag) tags.add(tag);
        tag = null;
    }
    
    return tags;
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
/**
 * @param executionContext
 * @param contentModel
 * @throws Exception
 */
@Override
public void process(final ExecutionContext executionContext, final TemplateContentModelImpl contentModel)
        throws ProcessException {
    try {
        SlingHttpServletRequest request = (SlingHttpServletRequest) executionContext.get(SLING_HTTP_REQUEST);
        Resource resource = request.getResource();
        log.debug("for {}", resource.getPath());
        if (resource != null) {
            ResourceResolver resourceResolver = request.getResourceResolver();
            Designer designer = resourceResolver.adaptTo(Designer.class);
            final PageManager pageManager = resourceResolver.adaptTo(PageManager.class);
            final TagManager tm = (TagManager) resource.getResourceResolver().adaptTo(TagManager.class);
            Page page = pageManager.getContainingPage(resource);
            if (page != null) {
                if (!contentModel.has(PAGE_PROPERTIES_KEY)) {
                    Configuration configuration = configurationProvider.getFor(page.getContentResource().getResourceType());
                    Collection<String> bodyClasses = configuration.asStrings(XK_CONTAINER_CLASSES_CP, Mode.MERGE);
                    Node pageContentNode = page.getContentResource().adaptTo(Node.class);
                    Map<String, Object> pageContent = propsToMap(pageContentNode.getProperties());
                    pageContent.put(PATH, page.getPath());
                    pageContent.put(PAGE_NAME, page.getName());
                    pageContent.put(LINK, page.getPath() + HTML_EXT);
                    pageContent.put(BODY_CLASSES, bodyClasses);
                    pageContent.put(TITLE, page.getTitle());
                    pageContent.put(DESCRIPTION, page.getProperties().get(JCR_DESCRIPTION, ""));
                    pageContent.put(PAGE_TITLE, page.getProperties().get(PAGE_TITLE, ""));
                    pageContent.put(SUBTITLE, page.getProperties().get(SUBTITLE, ""));
                    pageContent.put(HIDE_IN_NAV, page.getProperties().get(HIDE_IN_NAV, ""));
                    pageContent.put(KEYWORDS, PageUtils.getKeywords(pageContent, tm));
                    pageContent.put(TAGS, PageUtils.getTags(pageContent));
                    pageContent.put(WCM_MODE, GeneralRequestObjects.getWCMModeString(request));
                    pageContent.put(IS_EDIT_MODE, GeneralRequestObjects.isEditMode(request));
                    pageContent.put(IS_DESIGN_MODE, GeneralRequestObjects.isDesignMode(request));
                    pageContent.put(IS_EDIT_OR_DESIGN_MODE, GeneralRequestObjects.isEditOrDesignMode(request));

                    if (designer != null) {
                        Design design = designer.getDesign(page);
                        if (design != null && design.getPath() != null) {
                            pageContent.put(FAVICON, design.getPath() + "/" + FAVICON + ICO_EXT);
                        }
                    }

                    String navigationTitle = PageUtils.getNavigationTitle(page);
                    if (null != navigationTitle) {
                        pageContent.put(NAVIGATION_TITLE, PageUtils.getNavigationTitle(page));
                    }
                    // add transformed path image
                    String pageImagePath = assetPathService.getPageImagePath(page, page.getContentResource());
                    if(StringUtils.isNotEmpty(pageImagePath)){
                        pageContent.put(IMAGE_PATH, pageImagePath);
                    }

                    // add interface mode
                    if (AuthoringUIMode.fromRequest(request) == AuthoringUIMode.TOUCH) {
                        pageContent.put(IS_TOUCH_UI_MODE, true);
                        pageContent.put(IS_CLASSIC_UI_MODE, false);
                    } else {
                        pageContent.put(IS_CLASSIC_UI_MODE, true);
                        pageContent.put(IS_TOUCH_UI_MODE, false);
                    }
                    contentModel.set(PAGE_PROPERTIES_KEY, pageContent);
                }
            }
        }
    } catch (Exception e) {
        throw new ProcessException(e);
    }
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@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;
}
 

import com.day.cq.tagging.TagManager; //导入依赖的package包/类
@Test
public void testMergeAllTags() throws Exception {

    final TagManager mockTagManager = mock(TagManager.class);
    Tag fakeTag = mock(Tag.class);
    when(mockTagManager.resolve(any())).thenReturn(fakeTag);

    context.registerAdapter(ResourceResolver.class, TagManager.class, mockTagManager);

    ResourceResolver rr = context.resourceResolver();
    MockSlingHttpServletRequest request = context.request();
    request.setParameterMap(new HashMap<String, Object>() {
        {
            put("./asset/jcr:content/metadata/dam:tag1", new String[]{
                "tag1:tag1a",
                "tag1:tag1b"
            });
            put("./asset/jcr:content/metadata/dam:tag2", new String[]{
                "tag2:tag2a",
                "tag2:tag2b"
            });
            put(":" + PropertyMergePostProcessor.OPERATION_ALL_TAGS + "@PropertyMerge", "jcr:content/metadata/dam:combined-tags");
        }
    });

    Map<String, Object> emptyProperties = new HashMap<>();
    Resource content = rr.create(rr.resolve("/"), "content", emptyProperties);
    Resource dam = rr.create(content, "dam", emptyProperties);
    request.setResource(dam);
    Resource asset = rr.create(dam, "asset", emptyProperties);
    Resource jcrContent = rr.create(asset, "jcr:content", emptyProperties);
    Resource metadata = rr.create(jcrContent, "metadata", new HashMap<String, Object>() {
        {
            put("dam:tag1", new String[]{"tag1:tag1a", "tag1:tag1b"});
            put("dam:tag2", new String[]{"tag2:tag2a", "tag2:tag2b"});
        }
    });

    PropertyMergePostProcessor processor = new PropertyMergePostProcessor();
    List<Modification> changeLog = new ArrayList<>();
    processor.process(request, changeLog);
    Assert.assertFalse("Should have observed some changes", changeLog.isEmpty());
    String[] tags = metadata.getValueMap().get("dam:combined-tags", String[].class);
    Assert.assertArrayEquals(new String[]{"tag1:tag1a", "tag1:tag1b", "tag2:tag2a", "tag2:tag2b"}, tags);

}