[ {
"Capability" : "com.sdl.web.discovery.datalayer.model.ContentServiceCapability",
"id" : "DefaultContentService",
"lastUpdateTime" : 16663565840,
"uri" : "http://services.tridion.com:8081/content.svc"
}, {
"Capability" : "com.sdl.web.discovery.datalayer.model.TokenServiceCapability",
"id" : "DefaultTokenService",
"lastUpdateTime" : 16663565996,
"uri" : "http://services.tridion.com:8082/token.svc"
}, {
"Capability" : "com.sdl.web.discovery.datalayer.model.PreviewWebServiceCapability",
"id" : "DefaultPreviewWebService",
"lastUpdateTime" : 16663565934,
"uri" : "http://services.tridion.com:8083/ws/preview.svc"
} ]

<appSettings>
<addkey="discovery-service-uri"
value="http://services.tridion.com:8082/discovery.svc/"/>
...

<WrapperName="SessionWrapper">
<StorageType="persistence"Id="sessionDb"dialect="MSSQL"Class="com.tridion.storage.persistence.JPADAOFactory">
<PoolType="jdbc"Size="10"MonitorInterval="60"IdleTimeout="120"CheckoutTimeout="120"/>
<DataSourceClass="com.microsoft.sqlserver.jdbc.SQLServerDataSource">
<PropertyName="serverName"Value="db.tridion.com"/>
<PropertyName="portNumber"Value="1433"/>
<PropertyName="databaseName"Value="xpm-db"/>
<PropertyName="user"Value="XPMUser"/>
<PropertyName="password"Value="password"/>
</DataSource>
</Storage>
</Wrapper>

<WrapperName="SessionWrapper">
<StorageType="persistence"Id="sessionDb"dialect="MSSQL"Class="com.tridion.storage.persistence.JPADAOFactory">
<PoolType="jdbc"Size="10"MonitorInterval="60"IdleTimeout="120"CheckoutTimeout="120"/>
<DataSourceClass="com.microsoft.sqlserver.jdbc.SQLServerDataSource">
<PropertyName="serverName"Value="db.tridion.com"/>
<PropertyName="portNumber"Value="1433"/>
<PropertyName="databaseName"Value="xpm-db"/>
<PropertyName="user"Value="XPMUser"/>
<PropertyName="password"Value="password"/>
</DataSource>
</Storage>
</Wrapper>

{"error":"invalid_grant"}

<RequestValidator>com.sdl.web.oauth.validator.OAuth2RequestValidator</RequestValidator>

<!--RequestValidator>com.sdl.web.oauth.validator.OAuth2RequestValidator</RequestValidator-->

<RulesEnabled="false"/>

@PostConstruct
privatevoidregisterModels(){
    semanticMappingRegistry.registerEntities(getClass().getPackage().getName());
}

package com.mihaiconsulting.dxa.emerald;

importcom.mihaiconsulting.dxa.emerald.model.entity.MainNavigation;
importcom.sdl.webapp.common.api.mapping.semantic.SemanticMappingRegistry;
importcom.sdl.webapp.common.api.mapping.views.AbstractInitializer;
importcom.sdl.webapp.common.api.mapping.views.ModuleInfo;
importcom.sdl.webapp.common.api.mapping.views.RegisteredViewModel;
importcom.sdl.webapp.common.api.mapping.views.RegisteredViewModels;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Component;

importjavax.annotation.PostConstruct;

@org.springframework.context.annotation.Configuration
publicclassEmeraldInitializer{

@RegisteredViewModels({
@RegisteredViewModel(viewName ="MainNavigation", modelClass = MainNavigation.class)
})
@Component
@ModuleInfo(name ="Emerald module", areaName ="Emerald")
publicstaticclassEmeraldViewInitializerextends AbstractInitializer {

@Autowired
private SemanticMappingRegistry semanticMappingRegistry;

@Override
protected String getAreaName(){
return"Emerald";
}

@PostConstruct
privatevoidregisterModels(){
            semanticMappingRegistry.registerEntities(getClass().getPackage().getName());
}
}
}

<dependencies>
<dependency>
<groupId>com.sdl.dxa</groupId>
<artifactId>dxa-common-api</artifactId>
</dependency>

<!-- Servlet API -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>

<!-- Spring Framework -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
</dependencies>

package com.mihaiconsulting.dxa.emerald;

importcom.mihaiconsulting.dxa.emerald.model.entity.MainNavigation;
importcom.sdl.webapp.common.api.mapping.semantic.SemanticMappingRegistry;
importcom.sdl.webapp.common.api.mapping.views.AbstractInitializer;
importcom.sdl.webapp.common.api.mapping.views.ModuleInfo;
importcom.sdl.webapp.common.api.mapping.views.RegisteredViewModel;
importcom.sdl.webapp.common.api.mapping.views.RegisteredViewModels;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Component;

importjavax.annotation.PostConstruct;

@org.springframework.context.annotation.Configuration
publicclassEmeraldInitializer{

@RegisteredViewModels({
@RegisteredViewModel(viewName ="MainNavigation", modelClass = MainNavigation.class)
})
@Component
@ModuleInfo(name ="Emerald module", areaName ="Emerald")
publicstaticclassEmeraldViewInitializerextends AbstractInitializer {

@Autowired
private SemanticMappingRegistry semanticMappingRegistry;

@Override
protected String getAreaName(){
return"Emerald";
}

@PostConstruct
privatevoidregisterModels(){
            semanticMappingRegistry.registerEntities(getClass().getPackage().getName());
}
}
}

package com.mihaiconsulting.dxa.emerald.model.entity;

importcom.sdl.webapp.common.api.mapping.semantic.annotations.SemanticEntity;
importcom.sdl.webapp.common.api.mapping.semantic.annotations.SemanticProperty;
importcom.sdl.webapp.common.api.model.entity.AbstractEntityModel;

importjava.util.List;

@SemanticEntity(entityName ="MainNavigation", vocabulary ="http://www.sdl.com/web/schemas/core", prefix ="tri")
publicclassMainNavigationextends AbstractEntityModel {

@SemanticProperty("tri:name")
private String name;

@SemanticProperty("tri:links")
private List<NavigationLinks> links;

public String getName(){
return name;
}

publicvoidsetName(String name){
this.name= name;
}

public List<NavigationLinks>getLinks(){
return links;
}

publicvoidsetLinks(List<NavigationLinks> links){
this.links= links;
}
}

package com.mihaiconsulting.dxa.emerald.model.entity;

importcom.sdl.webapp.common.api.mapping.semantic.annotations.SemanticEntity;
importcom.sdl.webapp.common.api.mapping.semantic.annotations.SemanticProperty;
importcom.sdl.webapp.common.api.model.entity.AbstractEntityModel;

@SemanticEntity(entityName ="NavigationLinks", vocabulary ="http://www.sdl.com/web/schemas/core", prefix ="tri")
publicclassNavigationLinksextends AbstractEntityModel {

@SemanticProperty("tri:url")
private String url;

public String getUrl(){
return url;
}

publicvoidsetUrl(String url){
this.url= url;
}
}

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<jsp:useBean id="entity" type="com.mihaiconsulting.dxa.emerald.model.entity.MainNavigation" scope="request"/>

<div>
<p>Name: ${entity.name}</p>

<c:iftest="${not empty entity.links}">
        Links:
<ul>
<c:forEachvar="link"items="${entity.links}">
<li>${link.url}</li>
</c:forEach>
</ul>
</c:if>
</div>

<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scanbase-package="com.mihaiconsulting.dxa.emerald"/>

</beans>

<!-- Toolkit JSon Modules -->
<ProcessorAction="Deploy"Phase="post-transaction"Class="com.tridion.deployer.Processor">
<ModuleType="PageDeploy"Class="com.mitza.toolkit.deployer.JSonPageDeploy"/>
<ModuleType="ComponentDeploy"Class="com.mitza.toolkit.deployer.JSonComponentDeploy"/>
<ModuleType="ComponentPresentationDeploy"
Class="com.mitza.toolkit.deployer.JSonComponentPresentationDeploy"/>
<ModuleType="BinaryDeploy"Class="com.mitza.toolkit.deployer.JSonBinaryDeploy"/>
</Processor>

<ProcessorAction="Undeploy"Phase="post-transaction"Class="com.tridion.deployer.Processor">
<ModuleType="PageUndeploy"Class="com.mitza.toolkit.deployer.JSonPageUndeploy"/>
<ModuleType="ComponentPresentationUndeploy"
Class="com.mitza.toolkit.deployer.JSonComponentPresentationUndeploy"/>
</Processor>
<!-- End of Toolkit JSon Modules -->

<StorageBindings>
<Bundlesrc="toolkit_dao_bundle.xml"/>
</StorageBindings>

tag.name.1=mytag
tag.class.1=com.mitza.toolkit.tag.MyTag
tag.name.2=yourtag
tag.class.2=com.mitza.toolkit.tag.SecondTag

<?xml version="1.0" encoding="UTF-8"?>
<configurationscan="true">
<propertyname="log.pattern"value="%date [%thread] %5p %c{1} - %m%n"/>
<propertyname="log.level"value="info"/>

<appendername="STDOUT"class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
</appender>

<loggername="com.mitza"level="${log.level}"/>

<rootlevel="OFF">
<appender-refref="STDOUT"/>
</root>
</configuration>

ModelFactory modelFactory = ModelFactory.INSTANCE;

TcmUri tcmUri =new TcmUri(6,1225,64);
PageMeta model = modelFactory.getModel(tcmUri);

tcmUri =new TcmUri(6,52);
ComponentMeta componentMeta = modelFactory.getModel(tcmUri);

LinkFactory linkFactory = LinkFactory.INSTANCE;

Link link = linkFactory.getBinaryLink(6,84);
if(link.isResolved()){
    String url = link.getUrl();
}

// link to a Component
link = linkFactory.getComponentLink(6,52);
// link to a Component from a Page
link = linkFactory.getComponentLink(6,1138,1118);
// link to a Page
link = linkFactory.getPageLink(6,55);

ComponentPresentationFactory factory = ComponentPresentationFactory.INSTANCE;

ComponentPresentationMeta dcpMeta =
        factory.getComponentPresentationWithHighestPriority(6,1151);
if(dcpMeta !=null){
// unresolved content
    String content = dcpMeta.getContent();
}

dcpMeta = factory.getComponentPresentation(6,52,1117);

ComponentPresentationAssembler assembler = ComponentPresentationAssembler.INSTANCE;

String content = assembler.getContent(6,1151,1117);

TagFactory tagFactory = TagFactory.INSTANCE;

String content = tagFactory.executeTags("some <mytag>quick brown fox</mytag> content");

tag.name.1=mytag
tag.class.1=some.tag.example.MyTag

package some.tag.example;

importcom.mitza.toolkit.dynamic.TagRenderer;

publicclassMyTagimplements TagRenderer {

public String doTag(String tagBody){
// do actual processing here

return tagBody ==null?null: tagBody.toUpperCase();
}
}

Criterion criterion =new AndCriteria(
newCustomMetaCriterion("Type","Article"),
newPublicationCriterion(13)
);

Query query =new Query(criterion);
List<ComponentMeta> componentMetas = query.executeComponentQuery();

Criterion criterion =new AndCriteria(
        Arrays.asList(
newOrCriteria(
newPublicationCriterion(6),
newPublicationCriterion(8)
),
newCustomMetaCriterion("ReleaseDate",new Date(1450673126000L),new Date(1550673206000L),false),
newOrCriteria(
newCustomMetaCriterion("Type","Article"),
newCustomMetaCriterion("Type","News")
)
)
);
Query query =new Query(criterion);
List<PageMeta> pageMetas = query.executePageQuery();

Criterion criterion =new CustomMetaCriterion("String","LOLEK2");
Query query =new Query(criterion);
query.addSort("Type", SortDirection.ASCENDING);
query.addSort(SortColumn.LAST_PUBLISH, SortDirection.DESCENDING);
query.setPage(2);
query.setPageSize(25);

List<String> uris = query.executeQuery();

{
"cp" : [ {
"c" : 10,
"cnt" : "Rendered CP content",
"pr" : 300,
"p" : 6,
"t" : 15
  }, {
"c" : 10,
"cnt" : "Rendered CP content",
"pr" : 200,
"p" : 6,
"t" : 25
  } ],
"cstm" : {
"meta" : {
"Float" : {
"k" : "Price",
"n" : [ 2.0 ],
"t" : "NUMERIC"
      },
"Date" : {
"k" : "ArticleDate",
"d" : [ 72602000 ],
"t" : "DATE"
      },
"String" : {
"k" : "Authors",
"s" : [ "Lolek", "Bolek" ],
"t" : "STRING"
      }
    }
  },
"m" : 1450673231000,
"p" : 1482016384618,
"lnk" : [ {
"c" : 10,
"pg" : 20,
"pr" : 300,
"p" : 6,
"u" : "/page1.html"
  }, {
"c" : 10,
"pg" : 30,
"pr" : 300,
"p" : 6,
"u" : "/page2.html"
  } ],
"sch" : 46,
"tcm" : {
"p" : 6,
"i" : 10,
"t" : 16
  },
"t" : "News Article Sample",
"mm" : false
}

{
"cp" : [ {
"c" : 10,
"pr" : 200,
"p" : 6,
"t" : 15
  } ],
"f" : "/page3.html",
"m" : 1447029194000,
"p" : 1482016423976,
"pt" : 54,
"tcm" : {
"p" : 6,
"i" : 12,
"t" : 64
  },
"t" : "Sample Page 3",
"u" : "/page3.html"
}

public<T extends ItemMeta> T getOrCreateModel(TcmUri tcmUri){
    T model;
    String key = cacheFactory.getKey(tcmUri);
    CacheElement<T> cacheElement = cacheFactory.get(key);

if(cacheElement ==null){
        model = modelProvider.read(tcmUri);
}else{
        model = cacheElement.getPayload();
}

if(model ==null){
        model = modelProvider.create(tcmUri);
        cacheFactory.put(key, model);
}

return model;
}

public<T extends ItemMeta> T getModel(TcmUri tcmUri){
    T model;
    String key = cacheFactory.getKey(tcmUri);
    CacheElement<T> cacheElement = cacheFactory.get(key);

if(cacheElement ==null){
        model = modelProvider.read(tcmUri);
if(model !=null&& model.getLastPublished()==null){
            model =null;
}
        cacheFactory.put(key, model);
}else{
        model = cacheElement.getPayload();
}

return model;
}

public<T extends ItemMeta>void updateModel(T model){
    TcmUri tcmUri = model.getTcmUri();
    String key = cacheFactory.getKey(tcmUri);
    model = modelProvider.update(model);
    cacheFactory.put(key, model);
}

publicbooleanremoveModel(TcmUri tcmUri){
    String key = cacheFactory.getKey(tcmUri);
    cacheFactory.remove(key);

return modelProvider.delete(tcmUri);
}

public<T extends ItemMeta> T create(TcmUri tcmUri){
    T result;
    Class<T> aClass = ModelUtils.getClass(tcmUri);
try{
        result = aClass.newInstance();
        Method setTcmUri = aClass.getMethod("setTcmUri", TcmUri.class);
        setTcmUri.invoke(result, tcmUri);
}catch(InstantiationException | IllegalAccessException |
            NoSuchMethodException | InvocationTargetException e){
thrownewModelException(e);
}

return result;
}

public<T extends ItemMeta> T read(TcmUri tcmUri){
    String path = pathMapper.getModelAbsolutePath(tcmUri);
    File file =new File(path);
if(!file.exists()){
returnnull;
}

try{
        Class<T> aClass = ModelUtils.getClass(tcmUri);
        T model = serializer.deserialize(file, aClass);
return model;
}catch(SerializationException se){
thrownewModelException(se);
}
}

public<T extends ItemMeta> T update(T model){
    TcmUri tcmUri = model.getTcmUri();
    String path = pathMapper.getModelAbsolutePath(tcmUri);
    File file =new File(path);

if(!file.exists()){
        File directory = file.getParentFile();
if(!directory.exists()){
if(!directory.mkdirs()){
                log.error("Directory {} was not created", directory);
}
}
}

    serializer.serialize(file, model);

return model;
}

publicbooleandelete(TcmUri tcmUri){
    String path = pathMapper.getModelAbsolutePath(tcmUri);
    File file =new File(path);

if(file.exists()){
if(file.delete()){
if(isCleanup){
                deleteEmptyFolders(file.getParentFile());
}
returntrue;
}
}

returnfalse;
}

publicclassCacheElement<T>{

privatelong lastCheck;
private T payload;

publicCacheElement(T payload){
this.payload= payload;
        lastCheck = System.currentTimeMillis();
}

// accessor methods below...
}

public<T> CacheElement<T> get(String key){
    Element element = cache.get(key);
if(element ==null){
returnnull;
}else{
if(isStale(element)){
            remove(key);
returnnull;
}

        CacheElement<T> result =(CacheElement<T>) element.getObjectValue();

return result;
}
}

public<T>void put(String key, T payload){
    Element element =new Element(key,new CacheElement<>(payload));

if(cache.isKeyInCache(key)){
        cache.replace(element);
}else{
        cache.put(element);
}
}

publicbooleanremove(String key){
return cache.remove(key);
}

privatebooleanisStale(Element element){
    CacheElement<Object> cacheElement =(CacheElement<Object>) element.getObjectValue();
long lastCheck = cacheElement.getLastCheck();
long now = System.currentTimeMillis();

if(now - lastCheck > cacheMonitorInterval){
        cacheElement.setLastCheck(now);
        Object value = cacheElement.getPayload();

if(value instanceof IdentifiableObject){
            IdentifiableObject identifiableObject =(IdentifiableObject) value;
            TcmUri tcmUri = identifiableObject.getTcmUri();
            PathMapper pathMapper =new PathMapper();
            File file =new File(pathMapper.getModelAbsolutePath(tcmUri));

return!file.exists()|| file.lastModified()> lastCheck;
}
}

returnfalse;
}

public Link getComponentLink(TcmUri pageUri, TcmUri componentUri){
    LinkImpl result =new LinkImpl();
    ComponentMeta componentMeta = modelFactory.getModel(componentUri);
    List<LinkInfo> linkInfos = componentMeta.getLinkInfos();
if(linkInfos ==null|| linkInfos.size()==0){
return result;
}

    String[] urlParts;
    PageMeta pageMeta = modelFactory.getModel(pageUri);
if(pageMeta ==null){
        urlParts =new String[0];
}else{
        urlParts = pageMeta.getUrl().split("/");
}

int pageId = pageUri.getItemId();
int maxPriority =1;
int minDistance = Integer.MAX_VALUE;
    List<LinkInfo> filteredInfos =new ArrayList<>();

for(LinkInfo linkInfo : linkInfos){
if(linkInfo.getPage()!= pageId){
int distance = getDistance(urlParts, linkInfo.getUrl());
int priority = linkInfo.getPriority();
if(priority > maxPriority){
                maxPriority = priority;
                minDistance = distance;
                filteredInfos.clear();
}elseif(distance < minDistance){
                minDistance = distance;
                filteredInfos.clear();
}
if(priority == maxPriority && distance == minDistance){
                filteredInfos.add(linkInfo);
}
}
}

    LinkInfo linkInfo = getLastPublished(filteredInfos);
if(linkInfo !=null){
        result.setResolved(true);
        result.setUrl(linkInfo.getUrl());
        result.setTargetUri(new TcmUri(componentUri.getPublicationId(),
                linkInfo.getPage(), ItemTypes.PAGE));
}

return result;
}

privateintgetDistance(String[] parts, String url){
int result =0;

    String[] parts2 = url.split("/");
int n = Math.min(parts.length, parts2.length)-1;
int i =0;
boolean loop =true;

for(; i < n && loop; i++){
if(!parts[i].equals(parts2[i])){
            loop =false;
            i--;
}
}

    result += parts.length- i -1;
    result += parts2.length- i -1;

return result;
}

private LinkInfo getLastPublished(List<LinkInfo> linkInfos){
switch(linkInfos.size()){
case0:
returnnull;

case1:
return linkInfos.get(0);

default:
long maxPublished =0;
            LinkInfo result = linkInfos.get(0);

for(LinkInfo linkInfo : linkInfos){
                TcmUri metaUri =new TcmUri(linkInfo.getPublication(), linkInfo.getPage(), ItemTypes.PAGE);
                PageMeta pageMeta = modelFactory.getModel(metaUri);
if(pageMeta !=null){
long lastPublished = pageMeta.getLastPublished().getTime();
if(lastPublished > maxPublished){
                        maxPublished = lastPublished;
                        result = linkInfo;
}
}
}

return result;
}
}

public Link getPageLink(TcmUri pageUri){
    LinkImpl result =new LinkImpl();
    PageMeta pageMeta = modelFactory.getModel(pageUri);
if(pageMeta ==null){
return result;
}

    result.setResolved(true);
    result.setUrl(pageMeta.getUrl());
    result.setTargetUri(pageMeta.getTcmUri());

return result;
}

public Link getBinaryLink(TcmUri binaryUri, String variant){
    LinkImpl result =new LinkImpl();
    ComponentMeta binaryMeta = modelFactory.getModel(binaryUri);
if(binaryMeta ==null){
return result;
}

if(!binaryMeta.isMultimedia()){
return result;
}

    List<LinkInfo> linkInfos = binaryMeta.getLinkInfos();
if(linkInfos ==null|| linkInfos.size()==0){
return result;
}

    variant = variant ==null?"": variant;

for(LinkInfo linkInfo : linkInfos){
        String linkVariant = linkInfo.getVariant();
        linkVariant = linkVariant ==null?"": linkVariant;
if(variant.equals(linkVariant)){
            result.setResolved(true);
            result.setUrl(linkInfo.getUrl());
            result.setTargetUri(binaryUri);
break;
}
}

return result;
}

public ComponentPresentationMeta getComponentPresentation(int publicationId,int componentId,int templateId){
    TcmUri componentUri =new TcmUri(publicationId, componentId);
    ComponentMeta componentMeta = modelFactory.getModel(componentUri);
if(componentMeta ==null){
returnnull;
}

    List<ComponentPresentationMeta> dcpMetas = componentMeta.getDynamicComponentPresentationMetas();
if(dcpMetas ==null){
returnnull;
}

for(ComponentPresentationMeta meta : dcpMetas){
if(meta.getPublicationId()== publicationId && meta.getComponentId()== componentId &&
                meta.getTemplateId()== templateId){
return meta;
}
}

returnnull;
}

public ComponentPresentationMeta getComponentPresentationWithHighestPriority(int publicationId,int componentId){
    TcmUri componentUri =new TcmUri(publicationId, componentId);
    ComponentMeta componentMeta = modelFactory.getModel(componentUri);
if(componentMeta ==null){
returnnull;
}

    List<ComponentPresentationMeta> dcpMetas = componentMeta.getDynamicComponentPresentationMetas();
if(dcpMetas ==null){
returnnull;
}

int maxPriority =0;
    ComponentPresentationMeta result =null;

for(ComponentPresentationMeta meta : dcpMetas){
if(meta.getPriority()> maxPriority){
            maxPriority = meta.getPriority();
            result = meta;
}
}

return result;
}

public String getContent(int publicationId,int componentId,int templateId){
    ComponentPresentationMeta dcp = cpFactory.getComponentPresentation(
            publicationId, componentId, templateId);
if(dcp ==null){
returnnull;
}else{
        String content = dcp.getContent();
        content = TagFactory.INSTANCE.executeTags(content);

return content;
}
}

publicinterfaceTagRenderer{
    String doTag(String tagBody);
}

publicclassMyTagimplements TagRenderer {
public String doTag(String tagBody){
return tagBody.toUpperCase();
}
}

public String execute(String tagBody){
try{
return clazz.newInstance().doTag(tagBody);
}catch(IllegalAccessException | InstantiationException e){
thrownewTagException(e);
}
}

public String executeTags(String content){
    StringBuffer result =null;
    StringBuffer buffer =new StringBuffer(content);

for(TagSupport tag : tags){
        result =new StringBuffer();
        Matcher matcher = tag.getPattern().matcher(buffer);
while(matcher.find()){
            String tagBody = matcher.groupCount()>0? matcher.group(1):null;
            matcher.appendReplacement(result, tag.execute(tagBody));
}
        matcher.appendTail(result);
        buffer = result;
}

return result ==null? content : result.toString();
}

public List<String>executeQuery(){
    List<String> uris =new ArrayList<>(criterion.executeQuery());

    totalItemCount = uris.size();
    uris = applyPagination(uris);

return uris;
}

public List<ComponentMeta>executeComponentQuery(){
    List<String> uris =new ArrayList<>(criterion.executeQuery(
newFilterImpl(ItemTypes.COMPONENT)));
    List<ComponentMeta> result =new ArrayList<>(uris.size());
for(String uri : uris){
        TcmUri tcmUri =new TcmUri("tcm:"+ uri);
        ComponentMeta componentMeta = modelFactory.getModel(tcmUri);
if(componentMeta !=null){
            result.add(componentMeta);
}
}

    totalItemCount = result.size();
    Collections.sort(result, sorter);
    result = applyPagination(result);

return result;
}

public List<PageMeta>executePageQuery(){
    List<String> uris =new ArrayList<>(criterion.executeQuery(
newFilterImpl(ItemTypes.PAGE)));
    List<PageMeta> result =new ArrayList<>(uris.size());

for(String uri : uris){
        TcmUri tcmUri =new TcmUri("tcm:"+ uri);
        PageMeta pageMeta = modelFactory.getModel(tcmUri);
if(pageMeta !=null){
            result.add(pageMeta);
}
}
    totalItemCount = result.size();

if(sorter !=null){
        Collections.sort(result, sorter);
}

    result = applyPagination(result);
return result;
}

publicenum SortColumn {
    CUSTOM_META, LAST_MODIFIED, LAST_PUBLISH, TITLE
}

publicenum SortDirection {
    ASCENDING, DESCENDING
}

publicintcompare(ItemMeta i1, ItemMeta i2){
for(SortTerm sortTerm : sortTerms){
int compare = compare(i1, i2, sortTerm);
if(compare !=0){
return compare;
}
}

return0;
}

privateintcompare(ItemMeta i1, ItemMeta i2, SortTerm sortTerm){
    SortColumn column = sortTerm.getColumn();
    SortDirection direction = sortTerm.getDirection();

switch(column){
caseCUSTOM_META:
            String customMeta = sortTerm.getCustomMeta();
            CustomMetaItem customMetaItem1 = getCustomMetaItem(i1, customMeta);
            CustomMetaItem customMetaItem2 = getCustomMetaItem(i2, customMeta);
returncompare(customMetaItem1, customMetaItem2, direction);

caseLAST_MODIFIED:
            Date date1 = getLastModified(i1);
            Date date2 = getLastModified(i2);
return direction == SortDirection.ASCENDING?
                date1.compareTo(date2): date2.compareTo(date1);

caseLAST_PUBLISH:
            date1 = getLastPublished(i1);
            date2 = getLastPublished(i2);
return direction == SortDirection.ASCENDING?
                date1.compareTo(date2): date2.compareTo(date1);

caseTITLE:
            String title1 = getTitle(i1);
            String title2 = getTitle(i2);
return direction == SortDirection.ASCENDING?
                title1.compareTo(title2): title2.compareTo(title1);

default:
            log.error("Unknown sort column {}", column);
}

return0;
}

private CustomMetaItem getCustomMetaItem(ItemMeta itemMeta, String key){
if(itemMeta ==null){
returnnull;
}

    CustomMeta customMeta = itemMeta.getCustomMeta();
if(customMeta ==null){
returnnull;
}

    CustomMetaItem customMetaItem = customMeta.getByName(key);
if(customMetaItem ==null){
returnnull;
}

return customMetaItem;
}

privateintcompare(CustomMetaItem meta1, CustomMetaItem meta2, SortDirection direction){
if(meta1 ==null&& meta2 ==null){
return0;
}elseif(meta1 ==null){
return direction == SortDirection.ASCENDING?-1:1;
}elseif(meta2 ==null){
return direction == SortDirection.ASCENDING?1:-1;
}

    CustomMetaType type1 = meta1.getType();
    CustomMetaType type2 = meta2.getType();
if(type1 != type2){
        log.warn("Cannot compare custom meta {} with {}", type1, type2);
return1;
}

switch(type1){
caseDATE:
            Date date1 = meta1.getDateValue();
            date1 = date1 ==null? MIN_DATE : date1;
            Date date2 = meta2.getDateValue();
            date2 = date2 ==null? MIN_DATE : date2;
return direction == SortDirection.ASCENDING?
                date1.compareTo(date2): date2.compareTo(date1);

caseNUMERIC:
float float1 = meta1.getNumericValue();
float float2 = meta2.getNumericValue();
if(float1 == float2){
return0;
}elseif(float1 < float2){
return direction == SortDirection.ASCENDING?-1:1;
}else{
return direction == SortDirection.ASCENDING?1:-1;
}

caseSTRING:
            String string1 = join(meta1.getStringValues());
            String string2 = join(meta2.getStringValues());
return direction == SortDirection.ASCENDING?
                string1.compareTo(string2): string2.compareTo(string1);
}

return0;
}

private<T> List<T> applyPagination(List<T> items){
if(page ==0&& pageSize ==0){
return items;
}

int offset = page <=1|| pageSize <=0?0: Math.min(items.size(),(page -1)* pageSize);
int limit = pageSize <=0?0: Math.min(pageSize, items.size()- offset);

    List<T> result =new ArrayList<>(limit);
for(int i =0; i < limit; i++){
        T item = items.get(offset + i);
        result.add(item);
}

return result;
}

publicabstractclassCriterion{
public Set<String>executeQuery(){
returnexecuteQuery(FilterImpl.EMPTY_FILTER);
}

publicabstract Set<String>executeQuery(Filter filter);
}

public Set<String>executeQuery(Filter filter){
    String indexKey = stringIndex.buildKey(key, valueString);
returnnew TreeSet<>(stringIndex.get(indexKey, filter));
}

public Set<String>executeQuery(Filter filter){
    Set<String> result =null;
boolean first =true;

for(Criterion criterion : criteria){
        Set<String> criterionResult = criterion.executeQuery(filter);

if(first){
            first =false;
            result =new TreeSet<>(criterionResult);
}else{
            result.retainAll(criterionResult);
}
}

return result;
}