Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*************************************************************************
*
* ADOBE CONFIDENTIAL
* __________________
*
* Copyright 2012 Adobe Systems Incorporated
* All Rights Reserved.
*
* NOTICE: All information contained herein is, and remains
* the property of Adobe Systems Incorporated and its suppliers,
* if any. The intellectual and technical concepts contained
* herein are proprietary to Adobe Systems Incorporated and its
* suppliers and are protected by trade secret or copyright law.
* Dissemination of this information or reproduction of this material
* is strictly forbidden unless prior written permission is obtained
* from Adobe Systems Incorporated.
**************************************************************************/
package com.adobe.cq.social.srp.internal;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TimeZone;
import java.util.concurrent.Callable;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.Query;
import org.apache.lucene.util.Version;
import org.apache.sling.api.SlingConstants;
import org.apache.sling.api.SlingIOException;
import org.apache.sling.api.resource.ModifiableValueMap;
import org.apache.sling.api.resource.NonExistingResource;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.api.wrappers.ValueMapDecorator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.adobe.cq.social.srp.APICommand;
import com.adobe.cq.social.srp.APIException;
import com.adobe.cq.social.srp.APIResult;
import com.adobe.cq.social.srp.FacetRangeField;
import com.adobe.cq.social.srp.FacetSearchResult;
import com.adobe.cq.social.srp.IntervalFacetRangeField;
import com.adobe.cq.social.srp.ProviderMetaData;
import com.adobe.cq.social.srp.SearchSortField;
import com.adobe.cq.social.srp.SocialResourcePrefetch;
import com.adobe.cq.social.srp.SocialResourceProvider;
import com.adobe.cq.social.srp.SocialResourceSearchResult;
import com.adobe.cq.social.srp.config.ASRPConfiguration;
import com.adobe.cq.social.srp.config.DSRPConfiguration;
import com.adobe.cq.social.srp.config.MSRPConfiguration;
import com.adobe.cq.social.srp.config.SRPConfigurationError;
import com.adobe.cq.social.srp.config.SRPConfigurationFactory;
import com.adobe.cq.social.srp.config.SocialResourceConfiguration;
import com.adobe.cq.social.srp.internal.SocialDataService.BrowseDocumentsResult;
import com.adobe.cq.social.srp.internal.SocialDataService.Counts;
import com.adobe.cq.social.srp.utilities.api.SocialResourceUtilities;
import com.adobe.cq.social.srp.utilities.internal.InternalSocialResourceUtilities;
import com.adobe.granite.crypto.CryptoSupport;
import com.adobe.granite.security.user.UserProperties;
import com.day.cq.commons.Externalizer;
import com.day.cq.wcm.webservicesupport.Configuration;
/**
* A resource provider that can talk to a cloud.
*/
public class UGCCResourceProvider implements CachingResourceProvider {
/**
* Used to return an List<Resource> of matching children and a count of the matching children.
*/
private class ChildCountAndList extends SocialResourceSearchResult {
/**
* This class is not intended for serialization.
*/
private static final long serialVersionUID = 1L;
private Callable countChildren;
ChildCountAndList() {
// Ensure we note that we have no idea whether there are matching children or not.
setNumFound(-1);
}
/**
* Set a Callable which can use it's creator's state to know how to find the number of matching children.
* @param countChildren a Callable which will return the count of matching children.
*/
public void setCountChildren(final Callable countChildren) {
this.countChildren = countChildren;
}
/**
* This override is used so that if we don't already know the number of matching children we can call
* countChildren to obtain the number.
*/
@Override
public long getNumFound() {
final long numFound = super.getNumFound();
if (numFound < 0 && countChildren != null) {
try {
return countChildren.call();
} catch (final Exception e) {
LOGGER.warn("Calling count children failed.", e);
return -1;
}
}
return numFound;
}
}
// Simple regexp for the common cases
private static final String SINGLE_AND = "\\((\\w*) AND (\\w*)\\)";
private static final String SINGLE_OR = "\\((\\w*) OR (\\w*)\\)";
private static final String AND_PLUS_OR = "\\(\\(((\\w*) AND (\\w*)\\)) OR \\(((\\w*) AND (\\w*))\\)\\)";
private static final String FIELD_STATE_APPROVED = "approved";
private static final String FIELD_STATE_PENDING = "pending";
private static final String FIELD_STATE_DENIED = "denied";
private static final String FIELD_STATE_SPAM = "spam";
private static final int VISIBLE_ONLY_COUNT = 0;
private static final int ALL_COUNT = 1;
/** Max length for url that can be sent to AS. Don't know the exact number. */
public static final Integer QUERY_MAX_LENGTH = 4400;
/**
* For use in building cache key.
*/
private static final String RANGE_DATE_FORMAT = "yyyy-MM-dd-HH";
/**
* The property name for the user name.
*/
static final String USER_NAME_PROPERTY = "userIdentifier";
// This logic needs to correspond with what mod-3 does. In particular, this logic:
// https://git.corp.adobe.com/Social/adobe-social-moderation/blob/3.1/providers/
// soco/bundles/cq-social-moderation-soco-provider/src/main/java/com/adobe/cq/social/
// moderation/soco/impl/SocoDataPostProcessor.java#119
private static final String APPROVED_STRING = "-" + AbstractSchemaMapper.getSchemaApprovedKey() + ":false";
private static final String PENDING_STRING = "-" + AbstractSchemaMapper.getSchemaApprovedKey() + ":[\"\" TO *]";
private static final String DENIED_STRING = AbstractSchemaMapper.getSchemaApprovedKey() + ":false";
/** */
private static final Map ROOT_DOC;
private static final Logger LOGGER = LoggerFactory.getLogger(UGCCResourceProvider.class);
private static final String ATTACHMENT = "attachments";
private static final String NAME = "name";
// synthetic tallycount node where we store the values from the faceted search in the cache
private static final String TALLYCOUNT_NODE = "/tallycount";
private static final String CC_ASIPATH = "asipath";
private static final String CC_HOST_URL = "hosturl";
private static final String CC_REPORT_SUITE = "reportsuite";
private static final String CC_CONSUMER_KEY = "consumerkey";
private static final String CC_SECRET_KEY = "secret";
private final SocialDataService dsClient;
private final String providerBase;
private final Map commandsQueue = new LinkedHashMap();
private final Map> commandsAttachmentQueue =
new LinkedHashMap>();
private final Externalizer externalizer;
private final CryptoSupport cryptoSupport;
private final AbstractSchemaMapper mapper;
private final SRPConfigurationFactory srpConfigFactory;
private final ProviderCache documentCache;
private final CountCache visibleCountCache;
private final CountCache allCountCache;
private final AbstractCache>> facetCache;
private final StringListCache stringListCache;
private boolean configSet;
private ProviderMetaData metaData;
static {
ROOT_DOC = new HashMap();
ROOT_DOC.put("jcr:title", "Social Resource Provider Root");
}
/**
* Creates a new Resource Provider.
* @param client Adobe Cloud Storage API Client
* @param providerBase Base location of the provider.
* @param externalizer Used to externalize urls stored in Adobe Cloud Storage
* @param cryptoSupport a CryptoSupport impl
* @param documentCache the cache for docs
* @param visibleCountCache the cache for visible counts
* @param allCountCache the cache for all counts
* @param facetCache the cache for facets
* @param mapper the schema mapper
* @param stringListCache StringListCache
* @param srpConfigFactory the configuration factory
*/
public UGCCResourceProvider(final SocialDataService client, final String providerBase,
final Externalizer externalizer, final CryptoSupport cryptoSupport, final ProviderCache documentCache,
final CountCache allCountCache, final CountCache visibleCountCache,
final AbstractCache>> facetCache,
final StringListCache stringListCache, final AbstractSchemaMapper mapper,
final SRPConfigurationFactory srpConfigFactory) {
this.dsClient = client;
this.providerBase = providerBase;
this.externalizer = externalizer;
this.cryptoSupport = cryptoSupport;
this.documentCache = documentCache;
this.visibleCountCache = visibleCountCache;
this.allCountCache = allCountCache;
this.mapper = mapper;
this.facetCache = facetCache;
this.stringListCache = stringListCache;
this.srpConfigFactory = srpConfigFactory;
ROOT_DOC.put("type", client.getDSClient());
ROOT_DOC.put(SlingConstants.NAMESPACE_PREFIX + ":" + SlingConstants.PROPERTY_RESOURCE_TYPE, "social/asi/resourceprovider");
}
/**
* {@inheritDoc}
* @deprecated See {@link #getResource(ResourceResolver, String)}
*/
@Override
@Deprecated
public Resource getResource(final ResourceResolver resourceResolver, final HttpServletRequest request,
final String path) {
return this.getResource(resourceResolver, path);
}
/**
* Get the data service for this provider.
* @return the data service
*/
public SocialDataService getSocialDataService() {
return dsClient;
}
/**
* {@inheritDoc}
*/
@Override
public Resource getResource(final ResourceResolver resourceResolver, final String path) {
if (!StringUtils.startsWith(path, providerBase)) {
return null;
}
return getResourceWithoutCheck(resourceResolver, path);
}
/**
* Skip checking the provider base when getting a "special" resource.
* @param resourceResolver the resolver
* @param path the path
* @return the resource
*/
public Resource getResourceWithoutCheck(final ResourceResolver resourceResolver, final String path) {
return getResourceWithoutCheck(resourceResolver, path, false);
}
private CacheEntry createEntry(final Long result) {
return new CacheEntry(result);
}
/**
* Fetch a pending resource update (one that has been started, but not commited) if any.
* @param resolver the resolver
* @param path the path for the resource
* @return The updated resource if there is one pending. A NER if the requested resource has a pending delete.
* Null if there is nothing pending for this resource.
*/
private Resource getPendingResource(final ResourceResolver resolver, final String path) {
if (commandsQueue.containsKey(path)) {
final CommandResource command = commandsQueue.get(path);
if (command.methodType == APICommand.DELETE) {
return new NonExistingResource(resolver, path);
} else if (command.methodType == APICommand.CREATE) {
LOGGER.debug("Returning {} from pending creates cache.", path);
} else {
LOGGER.debug("Returning {} from pending updates cache.", path);
}
final MapResource cachedResource = command.getResource();
cachedResource.unlockMetadata();
return cachedResource;
}
if (commandsAttachmentQueue.containsKey(path)) {
final LinkedList commands = commandsAttachmentQueue.get(path);
final CommandResource lastCommand = commands.getLast();
if (lastCommand.methodType == APICommand.DELETE) {
return new NonExistingResource(resolver, path);
} else {
LOGGER.debug("Returning {} from pending creates cache.", path);
final MapResource cachedResource = lastCommand.getResource();
cachedResource.unlockMetadata();
return cachedResource;
}
}
return null;
}
private Resource getResourceWithoutCheck(final ResourceResolver resourceResolver, final String path,
final boolean recursedOnce) {
if (StringUtils.equals(providerBase, path)) {
// Identify this provider by returning a resource at it's root
return new MapResourceImpl(resourceResolver, this, path, ROOT_DOC, false);
}
if (SocialProviderUtils.isExtraneousSlingPath(resourceResolver, this, path)) {
return null;
}
if (!SocialResourceUtils.checkPermission(resourceResolver, getJcrAclPath(path), Session.ACTION_READ)) {
return null;
}
if (noConfig()) {
return null;
}
final Resource pendingResource = getPendingResource(resourceResolver, path);
if (pendingResource != null) {
if (ResourceUtil.isNonExistingResource(pendingResource)) {
return null;
} else {
return pendingResource;
}
}
Map doc = Collections.emptyMap();
final boolean isAttach = isAttachment(path);
final CacheEntry> cacheVal = documentCache.get(path);
if (cacheVal != null) {
LOGGER.debug("Got {} from cache.", path);
doc = new HashMap(cacheVal.get());
} else if (isAttach) {
try {
doc = dsClient.readAttachment(path);
} catch (final IOException e1) {
throw new SlingIOException(e1);
}
doc = mapper.fromAttachmentSchema(doc);
documentCache.put(path, documentCache.createEntry(doc, Collections.emptyMap()));
} else {
try {
doc = dsClient.readDocument(path);
} catch (final IOException e) {
LOGGER.error("Received exception when reading " + path, e);
throw new SlingIOException(e);
}
if (!doc.isEmpty()) {
doc = mapper.fromSchema(doc);
}
documentCache.put(path, documentCache.createEntry(doc, Collections.emptyMap()));
}
if (doc.isEmpty()) {
if (recursedOnce || isAttach) {
return null;
}
final int index = path.lastIndexOf('/');
if (index == -1) {
return null;
}
final String parentPath = path.substring(0, index);
final Resource resource = getResourceWithoutCheck(resourceResolver, parentPath, true);
if (resource != null) {
final String propertyKey = path.substring(index + 1);
final ValueMap map = resource.adaptTo(ValueMap.class);
final Object value = map.get(propertyKey);
if (value != null) {
// JCR uses the parent's resourcetype + the key value as the resource type. This does the
// same..
final Object resType =
map.get(SlingConstants.NAMESPACE_PREFIX + ":" + SlingConstants.PROPERTY_RESOURCE_TYPE);
if (resType != null) {
return new SocialPropertyResourceImpl(path, (String) resType, this, resourceResolver,
propertyKey, value);
}
}
}
return null;
}
return new MapResourceImpl(resourceResolver, this, path, doc, isAttach);
}
/**
* {@inheritDoc}
*/
@Override
public Resource create(final ResourceResolver resourceResolver, final String path,
final Map properties) throws PersistenceException {
boolean isAttachment = false;
String commitPath;
if (!SocialResourceUtils.checkPermission(resourceResolver, getJcrAclPath(path), Session.ACTION_ADD_NODE)) {
throw new PersistenceException(String.format("Not allowed to create resource at : %s", path));
}
if (StringUtils.equals(path, providerBase)) {
return null;
}
final Map propertiesCopy =
new HashMap(properties == null ? Collections.emptyMap() : properties);
if ((propertiesCopy.containsKey("nt:file")) && (propertiesCopy.get("nt:file") instanceof InputStream)) {
final String[] info = getPathSuffix(path);
commitPath = StringUtils.removeEnd(path, info[1]);
commitPath = StringUtils.stripEnd(commitPath, "/");
commitPath = StringUtils.stripEnd(commitPath, info[0]);
commitPath = commitPath + ATTACHMENT + "/" + info[1];
propertiesCopy.put(AbstractSchemaMapper.getSocoKey(), commitPath);
isAttachment = true;
} else {
if (!propertiesCopy.containsKey(AbstractSchemaMapper.getSocoParentIdKey())) {
final String parentId = ResourceUtil.getParent(path);
propertiesCopy.put(AbstractSchemaMapper.getSocoParentIdKey(), parentId);
}
commitPath = path;
}
final MapResource res = new MapResourceImpl(resourceResolver, this, commitPath, propertiesCopy, isAttachment);
if (isAttachment) {
if (propertiesCopy.containsKey(NAME)) {
String name = (String) (propertiesCopy.get(NAME));
if (!StringUtils.isEmpty(name) && (name.contains("[") || name.contains("]") || name.contains("/")
|| name.contains(":") || name.contains("|") || name.contains("*"))) {
throw new PersistenceException("FileName contains not supporting characters");
}
}
LinkedList commandResources;
if (commandsAttachmentQueue.containsKey(commitPath)) {
commandResources = commandsAttachmentQueue.get(commitPath);
commandResources.add(new CommandResource(path, APICommand.CREATE, res));
} else {
commandResources = new LinkedList();
commandResources.add(new CommandResource(path, APICommand.CREATE, res));
commandsAttachmentQueue.put(commitPath, commandResources);
}
} else {
commandsQueue.put(commitPath, new CommandResource(path, APICommand.CREATE, res));
}
return res;
}
/**
* {@inheritDoc}
*/
@Override
public void delete(final ResourceResolver resourceResolver, final String path) throws PersistenceException {
if (StringUtils.isEmpty(path)) {
return;
}
if (!SocialResourceUtils.checkPermission(resourceResolver, getJcrAclPath(path), Session.ACTION_REMOVE)) {
throw new PersistenceException(String.format("Not allowed to delete resource at : %s", path));
}
if (isAttachment(path)) {
LinkedList commandResources;
if (commandsAttachmentQueue.containsKey(path)) {
commandResources = commandsAttachmentQueue.get(path);
commandResources.add(new CommandResource(path, APICommand.DELETE, null));
} else {
commandResources = new LinkedList();
commandResources.add(new CommandResource(path, APICommand.DELETE, null));
commandsAttachmentQueue.put(path, commandResources);
}
} else {
commandsQueue.put(path, new CommandResource(path, APICommand.DELETE, null));
}
}
/**
* {@inheritDoc}
*/
@Override
public void revert(final ResourceResolver resourceResolver) {
commandsAttachmentQueue.clear();
commandsQueue.clear();
}
private void addModerationDetails(final ResourceResolver resolver, final Map map) {
if (map.containsKey(InternalSocialResourceUtilities.PN_ENTITY)
&& !map.containsKey(AbstractSchemaMapper.getSocoEntityUrlKey())) {
LOGGER.debug("Updating an existing entity URL which was previously not allowed: {}",
map.get(InternalSocialResourceUtilities.PN_ENTITY));
}
if (externalizer != null && map.containsKey(InternalSocialResourceUtilities.PN_ENTITY)
&& !StringUtils.isEmpty((String) map.get(InternalSocialResourceUtilities.PN_ENTITY))) {
map.put(AbstractSchemaMapper.getSocoEntityUrlKey(),
externalizer.publishLink(resolver, (String) map.remove(InternalSocialResourceUtilities.PN_ENTITY)));
}
addSocialSpecificFields(resolver, map);
}
private void addSocialSpecificFields(final ResourceResolver resolver, final Map map) {
if (map.containsKey(InternalSocialResourceUtilities.PN_CS_ROOT)
&& map.containsKey(InternalSocialResourceUtilities.PN_PARENTID)) {
final String parent = (String) map.get(InternalSocialResourceUtilities.PN_PARENTID);
final String root = (String) map.get(InternalSocialResourceUtilities.PN_CS_ROOT);
map.put(InternalSocialResourceUtilities.PN_IS_REPLY, !StringUtils.equals(parent, root));
}
if (map.containsKey(USER_NAME_PROPERTY) && map.containsKey(InternalSocialResourceUtilities.PN_CS_ROOT)) {
final UserProperties up =
SocialResourceUtils.getUserProperties(resolver, (String) map.get(USER_NAME_PROPERTY));
if (up != null) {
try {
final String displayName = up.getDisplayName();
map.put(AbstractSchemaMapper.getSocoAuthorDisplayNameKey(), displayName);
} catch (final RepositoryException e) {
LOGGER.error("Could not get display name!", e);
}
} else {
LOGGER.warn("Could not get user properties.");
}
}
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
@Override
public void commit(final ResourceResolver resourceResolver) throws PersistenceException {
try {
MapResource res = null;
// first deal with documents
final List commandList = new ArrayList();
for (final String key : commandsQueue.keySet()) {
final CommandResource command = commandsQueue.get(key);
final APICommand batchCommand;
if (command.methodType == APICommand.DELETE) {
batchCommand = new APICommand(command.methodType, command.key, null);
} else if (command.methodType == APICommand.INCREMENT) {
res = command.getResource();
final Map map = res.adaptTo(ModifiableValueMap.class);
// make sure there is a map under the key "$inc"
if (!map.containsKey(CachingResourceProvider.INC)
|| !(map.get(CachingResourceProvider.INC) instanceof Map)) {
throw new PersistenceException("Command to increment sent without an increment map");
}
final Map incMap = new HashMap();
incMap.put(CachingResourceProvider.INC, map.get(CachingResourceProvider.INC));
final Map temp = mapper.toSchema(incMap, command.key);
if (temp.containsKey(INC)) {
incMap.put(INC, temp.get(INC));
} else {
incMap.remove(INC);
}
if (temp.containsKey("cqdata")) {
incMap.put("cqdata", temp.get("cqdata"));
}
batchCommand =
new APICommand(APICommand.UPDATE, command.key, incMap, Collections.singletonMap(INC,
map.get(INC)));
} else {
res = command.getResource();
final Map map = res.adaptTo(Map.class);
addModerationDetails(resourceResolver, map);
final Map documentData = mapper.toSchema(map, command.key);
batchCommand = new APICommand(command.methodType, command.key, documentData, map);
}
commandList.add(batchCommand);
}
final List errorCodes = new ArrayList();
final List errorKeys = new ArrayList();
final List errorMethodTypes = new ArrayList();
if (!commandList.isEmpty()) {
final List apiResults = dsClient.batchCommit(commandList);
// iterate over each result, update the cache as appropriate depending on whether the result succeeded
for (int i = 0; i < apiResults.size(); i++) {
final APIResult apiResult = apiResults.get(i);
final APICommand apiCommand = commandList.get(i);
if (apiResult.getResult()) {
switch (apiCommand.methodType) {
case APICommand.CREATE:
// create cache entry (eventually, this should take the reportSuite as part of the
// key)
final CacheEntry> entry =
documentCache.createEntry(apiCommand.map,
((DocumentResult) apiResult).getDocument());
documentCache.put(apiCommand.providerId, entry);
// next, populate the count cache
final List cacheKey = new ArrayList(1);
final List cacheKeyWithBase = new ArrayList(2);
cacheKey.add(apiCommand.providerId);
cacheKeyWithBase.add(apiCommand.providerId);
final Long cacheCounts = 0L;
visibleCountCache.put(cacheKey, new CacheEntry(cacheCounts));
allCountCache.put(cacheKey, new CacheEntry(cacheCounts));
cacheKeyWithBase.add((String) apiCommand.map
.get(InternalSocialResourceUtilities.PN_BASETYPE));
visibleCountCache.put(cacheKeyWithBase, new CacheEntry(cacheCounts));
allCountCache.put(cacheKeyWithBase, new CacheEntry(cacheCounts));
LOGGER.debug("Creating cache entry for {}: {}", apiCommand.providerId, entry);
if (apiCommand.map.containsKey(AbstractSchemaMapper.getSocoParentIdKey())) {
final String parentKey =
(String) apiCommand.map.get(AbstractSchemaMapper.getSocoParentIdKey());
// remove parent count entry if exist and force a re-read for the count
removeAllMatchesFromCountCache(parentKey);
// remove listChidren cache entries with this parent and force a re-read next time
deleteListChildrenCache(parentKey);
facetCache.remove(parentKey);
}
break;
case APICommand.INCREMENT:
case APICommand.UPDATE:
mergeCacheContents(apiCommand.providerId, apiCommand.map,
mapper.fromSchema(((DocumentResult) apiResult).getDocument())); // update cache
// entry
break;
case APICommand.DELETE:
deleteDocumentFromCache(apiCommand.providerId); // delete cache entry
break;
}
} else {
// log the error and prepare the APIException arguments
final ErrorResult errorResult = (ErrorResult) apiResult;
if (apiCommand.methodType == APICommand.CREATE
&& errorResult.getCode() == ErrorResult.ERROR_DOCUMENT_ID_EXISTS) {
// make sure we don't hold onto a "doesn't exist" entry.
deleteDocumentFromCache(apiCommand.providerId);
} else {
LOGGER.error(errorResult.toString());
}
errorCodes.add(errorResult.getCode());
errorKeys.add(apiCommand.providerId);
errorMethodTypes.add(apiCommand.methodType);
}
}
}
// next, deal with attachments, respecting the order in which the commands were sent
for (final String key : commandsAttachmentQueue.keySet()) {
final LinkedList commandResources = commandsAttachmentQueue.get(key);
for (final CommandResource command : commandResources) {
switch (command.methodType) {
case APICommand.CREATE:
res = command.getResource();
final Map map = res.adaptTo(Map.class);
Map mappedMap;
mappedMap = mapper.toAttachmentSchema(map, key);
dsClient.addAttachment(key, mappedMap);
break;
case APICommand.DELETE:
dsClient.deleteAttachment(key);
break;
}
}
}
// clear the pending updates
commandsAttachmentQueue.clear();
commandsQueue.clear();
// finally, throw an error if needed
if (!errorKeys.isEmpty()) {
throw new APIException("Some of the modification operations failed", errorCodes, errorKeys,
errorMethodTypes);
}
} catch (final PersistenceException e) {
throw e;
} catch (final IOException e) {
throw new PersistenceException("Could not commit changes", e);
}
}
private void mergeCacheContents(final String key, final Map data,
final Map returnedResult) {
documentCache.merge(key, data, returnedResult);
// Need to update the facet cache entry of parent to reflect child update. However, for
// performance
// reasons, only if the doc being updated is already in the cache. That means it's possible
// that the parent child facets can be out of date and not reflect on the doc update
final CacheEntry> cached = documentCache.get(key);
if (cached != null) {
final Map docCacheEntry = cached.get();
if ((docCacheEntry != null) && docCacheEntry.containsKey(AbstractSchemaMapper.getSocoParentIdKey())) {
// just remove from cache for simplicity instead of doing math and updating the cache
facetCache.remove(docCacheEntry.get(AbstractSchemaMapper.getSocoParentIdKey()));
}
} else {
LOGGER.debug("Did not find key {} in document cache, so did not delete the parent in facet cache.", key);
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasChanges(final ResourceResolver resourceResolver) {
return !commandsAttachmentQueue.isEmpty() || !commandsQueue.isEmpty();
}
/**
* {@inheritDoc}
*/
@Override
public long countChildren(final Resource parent) {
return countChildren(parent, false);
}
/**
* {@inheritDoc}
*/
@Override
public long countChildren(final Resource parent, final boolean visibleOnly) {
return countChildren(parent, null, visibleOnly);
}
/**
* {@inheritDoc}
*/
@Override
public long countChildren(final Resource parent, final String childType) {
return countChildren(parent, childType, false);
}
@Override
public Map countChildren(final List parent, final String baseType,
final boolean visibleOnly) {
final Map retVal = new HashMap();
final CountCache countCache = visibleOnly ? visibleCountCache : allCountCache;
final List toFetch = new ArrayList(parent.size());
for (final Resource resource : parent) {
if (!SocialResourceUtils.checkPermission(resource.getResourceResolver(),
getJcrAclPath(resource.getPath()), Session.ACTION_READ)) {
retVal.put(resource.getPath(), 0L);
} else {
final List cacheKey = new ArrayList(2);
cacheKey.add(resource.getPath());
if (StringUtils.isNotEmpty(baseType)) {
cacheKey.add(baseType);
}
final CacheEntry cacheEntry = countCache.get(cacheKey);
if (cacheEntry != null) { // in cache
Long cacheCounts;
cacheCounts = cacheEntry.get();
if (cacheCounts != null && cacheCounts >= 0) {
retVal.put(resource.getPath(), cacheCounts);
} else {
toFetch.add(resource.getPath());
}
} else {
toFetch.add(resource.getPath());
}
}
}
if (!toFetch.isEmpty()) {
final Map fetched = this.countChildren(toFetch, visibleOnly, baseType);
retVal.putAll(fetched);
}
return retVal;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
@Override
public Iterator listChildren(final Resource parent) {
return listChildren(parent.getPath(), parent.getResourceResolver(), 0, -1, Collections.EMPTY_LIST);
}
/**
* {@inheritDoc}
*/
@Override
public Iterator listChildren(final String path, final ResourceResolver resourceResolver,
final int offset, final int size, final List> sortBy) {
return listChildren(path, null, resourceResolver, offset, size, sortBy, false);
}
@Override
public Iterator listChildren(final String path, final String baseType,
final ResourceResolver resourceResolver, final int offset, final int size,
final List> sortBy) {
return listChildren(path, baseType, resourceResolver, offset, size, sortBy, false);
}
/**
* Given a list of source paths, return a list of corresponding resources read from the cache only. If at least
* one resource is missing in the cache, then return null.
* @param stringList a List of resource paths
* @return a List of the corresponding resources read from the cache only. If at least 1 resource is missing from
* the cache, returns null.
*/
private ChildCountAndList childrenListFromCache(final ResourceResolver resolver, final List stringList) {
final ChildCountAndList resourceList = new ChildCountAndList();
for (final String path : stringList) {
final CacheEntry> cacheVal = documentCache.get(path);
if (cacheVal != null) {
final Map doc = new HashMap(cacheVal.get());
if (doc.isEmpty()) {
return null;
}
resourceList.add(new MapResourceImpl(resolver, this, path, doc, false));
} else {
return null;
}
}
// if we get here, we've found all resources in the cache
return resourceList;
}
/**
* Build a unique key to cache listChildren results using the listChildren params.
* @return a key that can used by StringListCache.
*/
private String buildListChildrenCacheKey(final String path, final String baseType, final int offset,
final int size, final List> sortBy, final boolean visibleOnly) {
// build a unique key to cache results
final List
