/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*******************************************************************************/
package org.apache.ofbiz.content;
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.StringUtil;
import org.apache.ofbiz.base.util.UtilDateTime;
import org.apache.ofbiz.base.util.UtilGenerics;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilProperties;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.base.util.cache.UtilCache;
import org.apache.ofbiz.content.content.ContentServices;
import org.apache.ofbiz.content.content.ContentWorker;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.condition.EntityCondition;
import org.apache.ofbiz.entity.condition.EntityOperator;
import org.apache.ofbiz.entity.model.ModelUtil;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtil;
import org.apache.ofbiz.security.Security;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.GenericServiceException;
import org.apache.ofbiz.service.LocalDispatcher;
import org.apache.ofbiz.service.ModelService;
import org.apache.ofbiz.service.ServiceAuthException;
import org.apache.ofbiz.service.ServiceUtil;
import com.ibm.icu.util.Calendar;
/**
* ContentManagementServices Class
*/
public class ContentManagementServices {
public static final String module = ContentManagementServices.class.getName();
public static final String resource = "ContentUiLabels";
/**
* getSubContent
* Finds the related subContent given the template Content and the mapKey.
* This service calls a same-named method in ContentWorker to do the work.
*/
public static Map<String, Object> getSubContent(DispatchContext dctx, Map<String, ? extends Object> context) {
Delegator delegator = dctx.getDelegator();
String contentId = (String) context.get("contentId");
String subContentId = (String) context.get("subContentId");
String mapKey = (String) context.get("mapKey");
GenericValue userLogin = (GenericValue)context.get("userLogin");
Timestamp fromDate = (Timestamp)context.get("fromDate");
List<String> assocTypes = UtilGenerics.checkList(context.get("assocTypes"));
String assocTypesString = (String)context.get("assocTypesString");
if (UtilValidate.isNotEmpty(assocTypesString)) {
List<String> lst = StringUtil.split(assocTypesString, "|");
if (assocTypes == null) {
assocTypes = new LinkedList<String>();
}
assocTypes.addAll(lst);
}
GenericValue content = null;
GenericValue view = null;
try {
view = ContentWorker.getSubContentCache(delegator, contentId, mapKey, subContentId, userLogin, assocTypes, fromDate, Boolean.FALSE, null);
content = ContentWorker.getContentFromView(view);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
Map<String, Object> results = ServiceUtil.returnSuccess();
results.put("view", view);
results.put("content", content);
return results;
}
/**
* getContent
* This service calls a same-named method in ContentWorker to do the work.
*/
public static Map<String, Object> getContent(DispatchContext dctx, Map<String, ? extends Object> context) {
Delegator delegator = dctx.getDelegator();
String contentId = (String) context.get("contentId");
GenericValue view = null;
try {
view = ContentWorker.getContentCache(delegator, contentId);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
Map<String, Object> results = ServiceUtil.returnSuccess();
results.put("view", view);
return results;
}
/**
* persistContentAndAssoc
* A combination method that will create or update all or one of the following:
* a Content entity, a ContentAssoc related to the Content, and
* the ElectronicText that may be associated with the Content.
* The keys for determining if each entity is created is the presence
* of the contentTypeId, contentAssocTypeId and dataResourceTypeId.
* This service tries to handle DataResource fields with and
* without "dr" prefixes.
* Assumes binary data is always in field, "imageData".
*
* This service does not accept straight ContentAssoc parameters. They must be prefaced with "ca" + cap first letter
*/
public static Map<String, Object> persistContentAndAssoc(DispatchContext dctx, Map<String, ? extends Object> rcontext) throws GenericServiceException {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Map<String, Object> context = UtilMisc.makeMapWritable(rcontext);
Locale locale = (Locale) context.get("locale");
// Knowing why a request fails permission check is one of the more difficult
// aspects of content management. Setting "displayFailCond" to true will
// put an html table in result.errorMessage that will show what tests were performed
Boolean bDisplayFailCond = (Boolean)context.get("displayFailCond");
String mapKey = (String) context.get("mapKey");
// If "deactivateExisting" is set, other Contents that are tied to the same
// contentIdTo will be deactivated (thruDate set to now)
String deactivateString = (String) context.get("deactivateExisting");
boolean deactivateExisting = "true".equalsIgnoreCase(deactivateString);
if (Debug.infoOn()) Debug.logInfo("in persist... mapKey(0):" + mapKey, module);
// ContentPurposes can get passed in as a delimited string or a list. Combine.
List<String> contentPurposeList = UtilGenerics.checkList(context.get("contentPurposeList"));
if (contentPurposeList == null) {
contentPurposeList = new LinkedList<String>();
}
String contentPurposeString = (String) context.get("contentPurposeString");
if (UtilValidate.isNotEmpty(contentPurposeString)) {
List<String> tmpPurposes = StringUtil.split(contentPurposeString, "|");
contentPurposeList.addAll(tmpPurposes);
}
if (contentPurposeList != null) {
context.put("contentPurposeList", contentPurposeList);
context.put("contentPurposeString", null);
}
if (Debug.infoOn()) {
Debug.logInfo("in persist... contentPurposeList(0):" + contentPurposeList, module);
Debug.logInfo("in persist... textData(0):" + context.get("textData"), module);
}
GenericValue content = delegator.makeValue("Content");
content.setPKFields(context);
content.setNonPKFields(context);
String contentId = (String) content.get("contentId");
String contentTypeId = (String) content.get("contentTypeId");
String origContentId = (String) content.get("contentId");
String origDataResourceId = (String) content.get("dataResourceId");
if (Debug.infoOn()) {
Debug.logInfo("in persist... contentId(0):" + contentId, module);
}
GenericValue dataResource = delegator.makeValue("DataResource");
dataResource.setPKFields(context);
dataResource.setNonPKFields(context);
dataResource.setAllFields(context, false, "dr", null);
String isPublic = (String) context.get("isPublic");
if(UtilValidate.isEmpty(isPublic)){
dataResource.set("isPublic", "N");
}
context.putAll(dataResource);
String dataResourceId = (String) dataResource.get("dataResourceId");
String dataResourceTypeId = (String) dataResource.get("dataResourceTypeId");
if (Debug.infoOn()) {
Debug.logInfo("in persist... dataResourceId(0):" + dataResourceId, module);
}
GenericValue contentAssoc = delegator.makeValue("ContentAssoc");
String contentAssocTypeId = (String)context.get("contentAssocTypeId");
if (UtilValidate.isNotEmpty(contentAssocTypeId)) {
context.put("caContentAssocTypeId", contentAssocTypeId);
}
contentAssocTypeId = (String)context.get("caContentAssocTypeId");
contentAssoc.setAllFields(context, false, "ca", null);
contentAssoc.put("contentId", context.get("caContentId"));
context.putAll(contentAssoc);
GenericValue electronicText = delegator.makeValue("ElectronicText");
electronicText.setPKFields(context);
electronicText.setNonPKFields(context);
// save expected primary keys on result now in case there is no operation that uses them
Map<String, Object> results = ServiceUtil.returnSuccess();
results.put("contentId", content.get("contentId"));
results.put("dataResourceId", dataResource.get("dataResourceId"));
results.put("drDataResourceId", dataResource.get("dataResourceId"));
results.put("drDataResourceId", dataResource.get("dataResourceId"));
results.put("caContentIdTo", contentAssoc.get("contentIdTo"));
results.put("caContentId", contentAssoc.get("contentId"));
results.put("caFromDate", contentAssoc.get("fromDate"));
results.put("caContentAssocTypeId", contentAssoc.get("contentAssocTypeId"));
// get user info for multiple use
GenericValue userLogin = (GenericValue) context.get("userLogin");
boolean dataResourceExists = true;
if (Debug.infoOn()) {
Debug.logInfo("in persist... dataResourceTypeId(0):" + dataResourceTypeId, module);
}
if (UtilValidate.isNotEmpty(dataResourceTypeId)) {
Map<String, Object> dataResourceResult = new HashMap<String, Object>();
try {
dataResourceResult = persistDataResourceAndDataMethod(dctx, context);
} catch (GenericServiceException e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
} catch (GenericEntityException e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
} catch (Exception e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
String errorMsg = ServiceUtil.getErrorMessage(dataResourceResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
dataResourceId = (String)dataResourceResult.get("dataResourceId");
results.put("dataResourceId", dataResourceId);
results.put("drDataResourceId", dataResourceId);
context.put("dataResourceId", dataResourceId);
content.put("dataResourceId", dataResourceId);
context.put("drDataResourceId", dataResourceId);
}
// Do update and create permission checks on Content if warranted.
context.put("skipPermissionCheck", null); // Force check here
boolean contentExists = true;
if (Debug.infoOn()) {
Debug.logInfo("in persist... contentTypeId:" + contentTypeId + " dataResourceTypeId:" + dataResourceTypeId + " contentId:" + contentId + " dataResourceId:" + dataResourceId, module);
}
if (UtilValidate.isNotEmpty(contentTypeId)) {
if (UtilValidate.isEmpty(contentId)) {
contentExists = false;
} else {
try {
GenericValue val = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne();
if (val == null) contentExists = false;
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
}
context.putAll(content);
if (contentExists) {
Map<String, Object> contentContext = new HashMap<String, Object>();
ModelService contentModel = dispatcher.getDispatchContext().getModelService("updateContent");
contentContext.putAll(contentModel.makeValid(content, "IN"));
contentContext.put("userLogin", userLogin);
contentContext.put("displayFailCond", bDisplayFailCond);
contentContext.put("skipPermissionCheck", context.get("skipPermissionCheck"));
Debug.logInfo("In persistContentAndAssoc calling updateContent with content: " + contentContext, module);
Map<String, Object> thisResult = dispatcher.runSync("updateContent", contentContext);
if (ServiceUtil.isError(thisResult) || ServiceUtil.isFailure(thisResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentContentUpdatingError", UtilMisc.toMap("serviceName", "persistContentAndAssoc"), locale), null, null, thisResult);
}
} else {
Map<String, Object> contentContext = new HashMap<String, Object>();
ModelService contentModel = dispatcher.getDispatchContext().getModelService("createContent");
contentContext.putAll(contentModel.makeValid(content, "IN"));
contentContext.put("userLogin", userLogin);
contentContext.put("displayFailCond", bDisplayFailCond);
contentContext.put("skipPermissionCheck", context.get("skipPermissionCheck"));
Debug.logInfo("In persistContentAndAssoc calling createContent with content: " + contentContext, module);
Map<String, Object> thisResult = dispatcher.runSync("createContent", contentContext);
if (ServiceUtil.isError(thisResult) || ServiceUtil.isFailure(thisResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentContentCreatingError", UtilMisc.toMap("serviceName", "persistContentAndAssoc"), locale), null, null, thisResult);
}
contentId = (String) thisResult.get("contentId");
}
results.put("contentId", contentId);
context.put("contentId", contentId);
context.put("caContentIdTo", contentId);
// Add ContentPurposes if this is a create operation
if (contentId != null && !contentExists) {
try {
if (contentPurposeList != null) {
Set<String> contentPurposeSet = UtilMisc.makeSetWritable(contentPurposeList);
for (String contentPurposeTypeId : contentPurposeSet) {
GenericValue contentPurpose = delegator.makeValue("ContentPurpose", UtilMisc.toMap("contentId", contentId, "contentPurposeTypeId", contentPurposeTypeId));
contentPurpose.create();
}
}
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
}
} else if (UtilValidate.isNotEmpty(dataResourceTypeId) && UtilValidate.isNotEmpty(contentId)) {
// If dataResource was not previously existing, then update the associated content with its id
if (UtilValidate.isNotEmpty(dataResourceId) && !dataResourceExists) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("userLogin", userLogin);
map.put("dataResourceId", dataResourceId);
map.put("contentId", contentId);
if (Debug.infoOn()) Debug.logInfo("in persist... context:" + context, module);
Map<String, Object> r = ContentServices.updateContentMethod(dctx, map);
boolean isError = ModelService.RESPOND_ERROR.equals(r.get(ModelService.RESPONSE_MESSAGE));
if (isError)
return ServiceUtil.returnError((String)r.get(ModelService.ERROR_MESSAGE));
}
}
// Put contentId
if (UtilValidate.isNotEmpty(contentId)) {
contentAssoc.put("contentIdTo", contentId);
}
// If parentContentIdTo or parentContentIdFrom exists, create association with newly created content
if (Debug.infoOn()) {
Debug.logInfo("CREATING contentASSOC contentAssocTypeId:" + contentAssocTypeId, module);
}
// create content assoc if the key values are present....
if (Debug.infoOn()) Debug.logInfo("contentAssoc: " + contentAssoc.toString(), module);
if (UtilValidate.isNotEmpty(contentAssocTypeId) && contentAssoc.get("contentId") != null && contentAssoc.get("contentIdTo") != null) {
if (Debug.infoOn()) Debug.logInfo("in persistContentAndAssoc, deactivateExisting:" + deactivateExisting, module);
Map<String, Object> contentAssocContext = new HashMap<String, Object>();
contentAssocContext.put("userLogin", userLogin);
contentAssocContext.put("displayFailCond", bDisplayFailCond);
contentAssocContext.put("skipPermissionCheck", context.get("skipPermissionCheck"));
Map<String, Object> thisResult = null;
try {
GenericValue contentAssocExisting = EntityQuery.use(delegator).from("ContentAssoc").where(contentAssoc.getPrimaryKey()).queryOne();
if (contentAssocExisting == null) {
ModelService contentAssocModel = dispatcher.getDispatchContext().getModelService("createContentAssoc");
Map<String, Object> ctx = contentAssocModel.makeValid(contentAssoc, "IN");
contentAssocContext.putAll(ctx);
thisResult = dispatcher.runSync("createContentAssoc", contentAssocContext);
String errMsg = ServiceUtil.getErrorMessage(thisResult);
if (ServiceUtil.isError(thisResult) || ServiceUtil.isFailure(thisResult) || UtilValidate.isNotEmpty(errMsg)) {
return ServiceUtil.returnError(errMsg);
}
results.put("caContentIdTo", thisResult.get("contentIdTo"));
results.put("caContentId", thisResult.get("contentIdFrom"));
results.put("caContentAssocTypeId", thisResult.get("contentAssocTypeId"));
results.put("caFromDate", thisResult.get("fromDate"));
results.put("caSequenceNum", thisResult.get("sequenceNum"));
} else {
if (deactivateExisting) {
contentAssocExisting.put("thruDate", UtilDateTime.nowTimestamp());
} else if (UtilValidate.isNotEmpty(context.get("thruDate"))) {
contentAssocExisting.put("thruDate", (Timestamp)context.get("thruDate"));
}
ModelService contentAssocModel = dispatcher.getDispatchContext().getModelService("updateContentAssoc");
Map<String, Object> ctx = contentAssocModel.makeValid(contentAssocExisting, "IN");
contentAssocContext.putAll(ctx);
thisResult = dispatcher.runSync("updateContentAssoc", contentAssocContext);
String errMsg = ServiceUtil.getErrorMessage(thisResult);
if (ServiceUtil.isError(thisResult) || ServiceUtil.isFailure(thisResult) || UtilValidate.isNotEmpty(errMsg)) {
return ServiceUtil.returnError(errMsg);
}
}
} catch (GenericEntityException e) {
throw new GenericServiceException(e.toString());
} catch (Exception e2) {
throw new GenericServiceException(e2.toString());
}
String errMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errMsg)) {
return ServiceUtil.returnError(errMsg);
}
}
context.remove("skipPermissionCheck");
context.put("contentId", origContentId);
context.put("dataResourceId", origDataResourceId);
context.remove("dataResource");
Debug.logInfo("results:" + results, module);
return results;
}
/**
Service for update publish sites with a ContentRole that will tie them to the passed
in party.
*/
public static Map<String, Object> updateSiteRoles(DispatchContext dctx, Map<String, ? extends Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
Delegator delegator = dctx.getDelegator();
GenericValue userLogin = (GenericValue)context.get("userLogin");
Map<String, Object> results = new HashMap<String, Object>();
String siteContentId = (String)context.get("contentId");
String partyId = (String)context.get("partyId");
if (UtilValidate.isEmpty(siteContentId) || UtilValidate.isEmpty(partyId))
return results;
List<GenericValue> siteRoles = null;
try {
siteRoles = EntityQuery.use(delegator).from("RoleType").where("parentTypeId", "BLOG").cache().queryList();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
for (GenericValue roleType : siteRoles) {
Map<String, Object> serviceContext = new HashMap<String, Object>();
serviceContext.put("partyId", partyId);
serviceContext.put("contentId", siteContentId);
serviceContext.put("userLogin", userLogin);
Debug.logInfo("updateSiteRoles, serviceContext(0):" + serviceContext, module);
String siteRole = (String)roleType.get("roleTypeId"); // BLOG_EDITOR, BLOG_ADMIN, etc.
String cappedSiteRole = ModelUtil.dbNameToVarName(siteRole);
if (Debug.infoOn()) {
Debug.logInfo("updateSiteRoles, cappediteRole(1):" + cappedSiteRole, module);
}
String siteRoleVal = (String)context.get(cappedSiteRole);
if (Debug.infoOn()) {
Debug.logInfo("updateSiteRoles, siteRoleVal(1):" + siteRoleVal, module);
Debug.logInfo("updateSiteRoles, context(1):" + context, module);
}
Object fromDate = context.get(cappedSiteRole + "FromDate");
if (Debug.infoOn()) {
Debug.logInfo("updateSiteRoles, fromDate(1):" + fromDate, module);
}
serviceContext.put("roleTypeId", siteRole);
if (siteRoleVal != null && siteRoleVal.equalsIgnoreCase("Y")) {
// for now, will assume that any error is due to duplicates - ignore
if (fromDate == null) {
try {
Map<String, Object> newContext = new HashMap<String, Object>();
newContext.put("contentId", serviceContext.get("contentId"));
newContext.put("partyId", serviceContext.get("partyId"));
newContext.put("roleTypeId", serviceContext.get("roleTypeId"));
newContext.put("userLogin", userLogin);
Map<String, Object> permResults = dispatcher.runSync("deactivateAllContentRoles", newContext);
serviceContext.put("fromDate", UtilDateTime.nowTimestamp());
if (Debug.infoOn()) Debug.logInfo("updateSiteRoles, serviceContext(1):" + serviceContext, module);
permResults = dispatcher.runSync("createContentRole", serviceContext);
String errMsg = ServiceUtil.getErrorMessage(permResults);
if (UtilValidate.isNotEmpty(errMsg)) {
return ServiceUtil.returnError(errMsg);
}
} catch (GenericServiceException e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
} catch (Exception e2) {
Debug.logError(e2, e2.toString(), module);
return ServiceUtil.returnError(e2.toString());
}
}
} else {
if (fromDate != null) {
// for now, will assume that any error is due to non-existence - ignore
try {
Debug.logInfo("updateSiteRoles, serviceContext(2):" + serviceContext, module);
Map<String, Object> newContext = new HashMap<String, Object>();
newContext.put("contentId", serviceContext.get("contentId"));
newContext.put("partyId", serviceContext.get("partyId"));
newContext.put("roleTypeId", serviceContext.get("roleTypeId"));
newContext.put("userLogin", userLogin);
Map<String, Object> permResults = dispatcher.runSync("deactivateAllContentRoles", newContext);
String errMsg = ServiceUtil.getErrorMessage(permResults);
if (UtilValidate.isNotEmpty(errMsg))
return ServiceUtil.returnError(errMsg);
} catch (GenericServiceException e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
} catch (Exception e2) {
Debug.logError(e2, e2.toString(), module);
return ServiceUtil.returnError(e2.toString());
}
}
}
}
return results;
}
public static Map<String, Object> persistDataResourceAndData(DispatchContext dctx, Map<String, ? extends Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
Locale locale = (Locale) context.get("locale");
Map<String, Object> result = new HashMap<String, Object>();
try {
ModelService checkPermModel = dispatcher.getDispatchContext().getModelService("checkContentPermission");
Map<String, Object> ctx = checkPermModel.makeValid(context, "IN");
Map<String, Object> thisResult = dispatcher.runSync("checkContentPermission", ctx);
String permissionStatus = (String)thisResult.get("permissionStatus");
if (UtilValidate.isNotEmpty(permissionStatus) && permissionStatus.equalsIgnoreCase("granted")) {
result = persistDataResourceAndDataMethod(dctx, context);
}
else {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentContentNoAccessToUploadImage", locale));
}
} catch (GenericServiceException e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
} catch (GenericEntityException e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
} catch (Exception e) {
Debug.logError(e, e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
String errorMsg = ServiceUtil.getErrorMessage(result);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
return result;
}
public static Map<String, Object> persistDataResourceAndDataMethod(DispatchContext dctx, Map<String, ? extends Object> rcontext) throws GenericServiceException, GenericEntityException, Exception {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Map<String, Object> context = UtilMisc.makeMapWritable(rcontext);
Map<String, Object> result = new HashMap<String, Object>();
Map<String, Object> newDrContext = new HashMap<String, Object>();
GenericValue dataResource = delegator.makeValue("DataResource");
dataResource.setPKFields(context);
dataResource.setNonPKFields(context);
dataResource.setAllFields(context, false, "dr", null);
context.putAll(dataResource);
GenericValue electronicText = delegator.makeValue("ElectronicText");
electronicText.setPKFields(context);
electronicText.setNonPKFields(context);
String textData = (String)electronicText.get("textData");
String dataResourceId = (String)dataResource.get("dataResourceId");
String dataResourceTypeId = (String)dataResource.get("dataResourceTypeId");
if (Debug.infoOn()) {
Debug.logInfo("in persist... dataResourceId(0):" + dataResourceId, module);
}
context.put("skipPermissionCheck", "granted"); // TODO: a temp hack because I don't want to bother with DataResource permissions at this time.
boolean dataResourceExists = true;
if (UtilValidate.isEmpty(dataResourceId)) {
dataResourceExists = false;
} else {
try {
GenericValue val = EntityQuery.use(delegator).from("DataResource").where("dataResourceId", dataResourceId).queryOne();
if (val == null) {
dataResourceExists = false;
}
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
}
GenericValue userLogin = (GenericValue) context.get("userLogin");
ModelService dataResourceModel = dispatcher.getDispatchContext().getModelService("updateDataResource");
Map<String, Object> ctx = dataResourceModel.makeValid(dataResource, "IN");
newDrContext.putAll(ctx);
newDrContext.put("userLogin", userLogin);
newDrContext.put("skipPermissionCheck", context.get("skipPermissionCheck"));
ByteBuffer imageDataBytes = (ByteBuffer) context.get("imageData");
String mimeTypeId = (String) newDrContext.get("mimeTypeId");
if (imageDataBytes != null && (mimeTypeId == null || (mimeTypeId.indexOf("image") >= 0) || (mimeTypeId.indexOf("application") >= 0))) {
mimeTypeId = (String) context.get("_imageData_contentType");
if (dataResourceTypeId.equals("IMAGE_OBJECT")) {
String fileName = (String) context.get("_imageData_fileName");
newDrContext.put("objectInfo", fileName);
}
newDrContext.put("mimeTypeId", mimeTypeId);
}
if (!dataResourceExists) { // Create
Map<String, Object> thisResult = dispatcher.runSync("createDataResource", newDrContext);
String errorMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
throw(new Exception(errorMsg));
}
dataResourceId = (String)thisResult.get("dataResourceId");
if (Debug.infoOn()) {
Debug.logInfo("in persist... dataResourceId(0):" + dataResourceId, module);
}
dataResource = (GenericValue)thisResult.get("dataResource");
Map<String, Object> fileContext = new HashMap<String, Object>();
fileContext.put("userLogin", userLogin);
if (dataResourceTypeId.equals("IMAGE_OBJECT")) {
if (imageDataBytes != null) {
fileContext.put("dataResourceId", dataResourceId);
fileContext.put("imageData", imageDataBytes);
thisResult = dispatcher.runSync("createImage", fileContext);
errorMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
}
} else if (dataResourceTypeId.equals("SHORT_TEXT")) {
} else if (dataResourceTypeId.startsWith("SURVEY")) {
} else if (dataResourceTypeId.indexOf("_FILE") >=0) {
Map<String, Object> uploadImage = new HashMap<String, Object>();
uploadImage.put("userLogin", userLogin);
uploadImage.put("dataResourceId", dataResourceId);
uploadImage.put("dataResourceTypeId", dataResourceTypeId);
uploadImage.put("rootDir", context.get("objectInfo"));
uploadImage.put("uploadedFile", imageDataBytes);
uploadImage.put("_uploadedFile_fileName", (String) context.get("_imageData_fileName"));
uploadImage.put("_uploadedFile_contentType", (String) context.get("_imageData_contentType"));
dispatcher.runSync("attachUploadToDataResource", uploadImage);
} else {
// assume ELECTRONIC_TEXT
if (UtilValidate.isNotEmpty(textData)) {
fileContext.put("dataResourceId", dataResourceId);
fileContext.put("textData", textData);
thisResult = dispatcher.runSync("createElectronicText", fileContext);
errorMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
}
}
} else { // Update
Map<String, Object> thisResult = dispatcher.runSync("updateDataResource", newDrContext);
String errorMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
Map<String, Object> fileContext = new HashMap<String, Object>();
fileContext.put("userLogin", userLogin);
String forceElectronicText = (String)context.get("forceElectronicText");
if (dataResourceTypeId.equals("IMAGE_OBJECT")) {
if (imageDataBytes != null || "true".equalsIgnoreCase(forceElectronicText)) {
fileContext.put("dataResourceId", dataResourceId);
fileContext.put("imageData", imageDataBytes);
thisResult = dispatcher.runSync("updateImage", fileContext);
errorMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
}
} else if (dataResourceTypeId.equals("SHORT_TEXT")) {
} else if (dataResourceTypeId.startsWith("SURVEY")) {
} else if (dataResourceTypeId.indexOf("_FILE") >=0) {
Map<String, Object> uploadImage = new HashMap<String, Object>();
uploadImage.put("userLogin", userLogin);
uploadImage.put("dataResourceId", dataResourceId);
uploadImage.put("dataResourceTypeId", dataResourceTypeId);
uploadImage.put("rootDir", context.get("objectInfo"));
uploadImage.put("uploadedFile", imageDataBytes);
uploadImage.put("_uploadedFile_fileName", (String) context.get("_imageData_fileName"));
uploadImage.put("_uploadedFile_contentType", (String) context.get("_imageData_contentType"));
dispatcher.runSync("attachUploadToDataResource", uploadImage);
} else {
if (UtilValidate.isNotEmpty(textData) || "true".equalsIgnoreCase(forceElectronicText)) {
fileContext.put("dataResourceId", dataResourceId);
fileContext.put("textData", textData);
thisResult = dispatcher.runSync("updateElectronicText", fileContext);
errorMsg = ServiceUtil.getErrorMessage(thisResult);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
}
}
}
result.put("dataResourceId", dataResourceId);
result.put("drDataResourceId", dataResourceId);
context.put("dataResourceId", dataResourceId);
return result;
}
public static void addRoleToUser(Delegator delegator, LocalDispatcher dispatcher, Map<String, Object> serviceContext) throws GenericServiceException, GenericEntityException {
List<GenericValue> userLoginList = EntityQuery.use(delegator).from("UserLogin").where("partyId", serviceContext.get("partyId")).queryList();
for (GenericValue partyUserLogin : userLoginList) {
String partyUserLoginId = partyUserLogin.getString("userLoginId");
serviceContext.put("contentId", partyUserLoginId); // author contentId
dispatcher.runSync("createContentRole", serviceContext);
}
}
public static Map<String, Object> updateSiteRolesDyn(DispatchContext dctx, Map<String, ? extends Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
Delegator delegator = dctx.getDelegator();
Map<String, Object> results = new HashMap<String, Object>();
Map<String, Object> serviceContext = new HashMap<String, Object>();
// siteContentId will equal "ADMIN_MASTER", "AGINC_MASTER", etc.
// Remember that this service is called in the "multi" mode,
// with a new siteContentId each time.
// siteContentId could also have been name deptContentId, since this same
// service is used for updating department roles, too.
String siteContentId = (String)context.get("contentId");
String partyId = (String)context.get("partyId");
serviceContext.put("partyId", partyId);
serviceContext.put("contentId", siteContentId);
List<GenericValue> siteRoles = null;
try {
siteRoles = EntityQuery.use(delegator).from("RoleType").where("parentTypeId", "BLOG").cache().queryList();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
for (GenericValue roleType : siteRoles) {
String siteRole = (String)roleType.get("roleTypeId"); // BLOG_EDITOR, BLOG_ADMIN, etc.
String cappedSiteRole = ModelUtil.dbNameToVarName(siteRole);
String siteRoleVal = (String)context.get(cappedSiteRole);
Object fromDate = context.get(cappedSiteRole + "FromDate");
serviceContext.put("roleTypeId", siteRole);
if (siteRoleVal != null && siteRoleVal.equalsIgnoreCase("Y")) {
// for now, will assume that any error is due to duplicates - ignore
if (fromDate == null) {
try {
serviceContext.put("fromDate", UtilDateTime.nowTimestamp());
if (Debug.infoOn()) {
Debug.logInfo("updateSiteRoles, serviceContext(1):" + serviceContext, module);
}
addRoleToUser(delegator, dispatcher, serviceContext);
dispatcher.runSync("createContentRole", serviceContext);
} catch (GenericServiceException e) {
Debug.logError(e, e.toString(), module);
} catch (Exception e2) {
Debug.logError(e2, e2.toString(), module);
}
}
} else {
if (fromDate != null) {
// for now, will assume that any error is due to non-existence - ignore
//return ServiceUtil.returnError(e.toString());
try {
Debug.logInfo("updateSiteRoles, serviceContext(2):" + serviceContext, module);
Map<String, Object> newContext = new HashMap<String, Object>();
newContext.put("contentId", serviceContext.get("contentId"));
newContext.put("partyId", serviceContext.get("partyId"));
newContext.put("roleTypeId", serviceContext.get("roleTypeId"));
dispatcher.runSync("deactivateAllContentRoles", newContext);
} catch (GenericServiceException e) {
Debug.logError(e, e.toString(), module);
} catch (Exception e2) {
Debug.logError(e2, e2.toString(), module);
}
}
}
}
return results;
}
public static Map<String, Object> updateOrRemove(DispatchContext dctx, Map<String, ? extends Object> context) {
Map<String, Object> results = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
String entityName = (String)context.get("entityName");
String action = (String)context.get("action");
String pkFieldCount = (String)context.get("pkFieldCount");
Map<String, String> pkFields = new HashMap<String, String>();
int fieldCount = Integer.parseInt(pkFieldCount);
for (int i=0; i<fieldCount; i++) {
String fieldName = (String)context.get("fieldName" + i);
String fieldValue = (String)context.get("fieldValue" + i);
if (UtilValidate.isEmpty(fieldValue)) {
// It may be the case that the last row in a form is "empty" waiting for
// someone to enter a value, in which case we do not want to throw an
// error, we just want to ignore it.
return results;
}
pkFields.put(fieldName, fieldValue);
}
boolean doLink = (action != null && action.equalsIgnoreCase("Y")) ? true : false;
if (Debug.infoOn()) {
Debug.logInfo("in updateOrRemove, context:" + context, module);
}
try {
GenericValue entityValuePK = delegator.makeValue(entityName, pkFields);
if (Debug.infoOn()) {
Debug.logInfo("in updateOrRemove, entityValuePK:" + entityValuePK, module);
}
GenericValue entityValueExisting = EntityQuery.use(delegator).from(entityName).where(entityValuePK).cache().queryOne();
if (Debug.infoOn()) {
Debug.logInfo("in updateOrRemove, entityValueExisting:" + entityValueExisting, module);
}
if (entityValueExisting == null) {
if (doLink) {
entityValuePK.create();
if (Debug.infoOn()) {
Debug.logInfo("in updateOrRemove, entityValuePK: CREATED", module);
}
}
} else {
if (!doLink) {
entityValueExisting.remove();
if (Debug.infoOn()) {
Debug.logInfo("in updateOrRemove, entityValueExisting: REMOVED", module);
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return results;
}
public static Map<String, Object> resequence(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
String contentIdTo = (String)context.get("contentIdTo");
Integer seqInc = (Integer)context.get("seqInc");
if (seqInc == null) {
seqInc = Integer.valueOf(100);
}
int seqIncrement = seqInc.intValue();
List<String> typeList = UtilGenerics.checkList(context.get("typeList"));
if (typeList == null) {
typeList = new LinkedList<String>();
}
String contentAssocTypeId = (String)context.get("contentAssocTypeId");
if (UtilValidate.isNotEmpty(contentAssocTypeId)) {
typeList.add(contentAssocTypeId);
}
if (UtilValidate.isEmpty(typeList)) {
typeList = UtilMisc.toList("PUBLISH_LINK", "SUB_CONTENT");
}
EntityCondition conditionType = EntityCondition.makeCondition("contentAssocTypeId", EntityOperator.IN, typeList);
EntityCondition conditionMain = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("contentIdTo", EntityOperator.EQUALS, contentIdTo), conditionType), EntityOperator.AND);
try {
List<GenericValue> listAll = EntityQuery.use(delegator).from("ContentAssoc")
.where(conditionMain)
.orderBy("sequenceNum", "fromDate", "createdDate")
.filterByDate().queryList();
String contentId = (String)context.get("contentId");
String dir = (String)context.get("dir");
int seqNum = seqIncrement;
String thisContentId = null;
for (int i=0; i < listAll.size(); i++) {
GenericValue contentAssoc = listAll.get(i);
if (UtilValidate.isNotEmpty(contentId) && UtilValidate.isNotEmpty(dir)) {
// move targeted entry up or down
thisContentId = contentAssoc.getString("contentId");
if (contentId.equals(thisContentId)) {
if (dir.startsWith("up")) {
if (i > 0) {
// Swap with previous entry
try {
GenericValue prevValue = listAll.get(i-1);
Long prevSeqNum = (Long)prevValue.get("sequenceNum");
prevValue.put("sequenceNum", Long.valueOf(seqNum));
prevValue.store();
contentAssoc.put("sequenceNum", prevSeqNum);
contentAssoc.store();
} catch (Exception e) {
return ServiceUtil.returnError(e.toString());
}
}
} else {
if (i < listAll.size()) {
// Swap with next entry
GenericValue nextValue = listAll.get(i+1);
nextValue.put("sequenceNum", Long.valueOf(seqNum));
nextValue.store();
seqNum += seqIncrement;
contentAssoc.put("sequenceNum", Long.valueOf(seqNum));
contentAssoc.store();
i++; // skip next one
}
}
} else {
contentAssoc.put("sequenceNum", Long.valueOf(seqNum));
contentAssoc.store();
}
} else {
contentAssoc.put("sequenceNum", Long.valueOf(seqNum));
contentAssoc.store();
}
seqNum += seqIncrement;
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> changeLeafToNode(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
String contentId = (String)context.get("contentId");
GenericValue userLogin = (GenericValue)context.get("userLogin");
String userLoginId = userLogin.getString("userLoginId");
Locale locale = (Locale) context.get("locale");
try {
GenericValue content = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne();
if (content == null) {
Debug.logError("content was null", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentNoContentFound", UtilMisc.toMap("contentId", ""), locale));
}
String dataResourceId = content.getString("dataResourceId");
content.set("dataResourceId", null);
content.set("lastModifiedDate", UtilDateTime.nowTimestamp());
content.set("lastModifiedByUserLogin", userLoginId);
content.store();
if (UtilValidate.isNotEmpty(dataResourceId)) {
// add previous DataResource as part of new subcontent
GenericValue contentClone = (GenericValue)content.clone();
contentClone.set("dataResourceId", dataResourceId);
content.set("lastModifiedDate", UtilDateTime.nowTimestamp());
content.set("lastModifiedByUserLogin", userLoginId);
content.set("createdDate", UtilDateTime.nowTimestamp());
content.set("createdByUserLogin", userLoginId);
contentClone.set("contentId", null);
ModelService modelService = dctx.getModelService("persistContentAndAssoc");
Map<String, Object> serviceIn = modelService.makeValid(contentClone, "IN");
serviceIn.put("userLogin", userLogin);
serviceIn.put("contentIdTo", contentId);
serviceIn.put("contentAssocTypeId", "SUB_CONTENT");
serviceIn.put("sequenceNum", Long.valueOf(50));
try {
dispatcher.runSync("persistContentAndAssoc", serviceIn);
} catch (ServiceAuthException e) {
return ServiceUtil.returnError(e.toString());
}
List<String> typeList = UtilMisc.toList("SUB_CONTENT");
ContentManagementWorker.updateStatsTopDown(delegator, contentId, typeList);
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> updateLeafCount(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
List<String> typeList = UtilGenerics.checkList(context.get("typeList"));
if (typeList == null) {
typeList = UtilMisc.toList("PUBLISH_LINK", "SUB_CONTENT");
}
String startContentId = (String)context.get("contentId");
try {
int leafCount = ContentManagementWorker.updateStatsTopDown(delegator, startContentId, typeList);
result.put("leafCount", Integer.valueOf(leafCount));
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return result;
}
/**
* This service changes the contentTypeId of the current content and its children depending on the pageMode.
* if pageMode == "outline" then if the contentTypeId of children is not "OUTLINE_NODE" or "PAGE_NODE"
* (it could be DOCUMENT or SUBPAGE_NODE) then it will get changed to PAGE_NODE.`
* if pageMode == "page" then if the contentTypeId of children is not "PAGE_NODE" or "SUBPAGE_NODE"
* (it could be DOCUMENT or OUTLINE_NODE) then it will get changed to SUBPAGE_NODE.`
*/
public static Map<String, Object> updatePageType(DispatchContext dctx, Map<String, ? extends Object> rcontext) throws GenericServiceException{
Delegator delegator = dctx.getDelegator();
Map<String, Object> context = UtilMisc.makeMapWritable(rcontext);
Map<String, Object> results = new HashMap<String, Object>();
Locale locale = (Locale) context.get("locale");
Set<String> visitedSet = UtilGenerics.checkSet(context.get("visitedSet"));
if (visitedSet == null) {
visitedSet = new HashSet<String>();
context.put("visitedSet", visitedSet);
}
String pageMode = (String)context.get("pageMode");
String contentId = (String)context.get("contentId");
visitedSet.add(contentId);
String contentTypeId = "PAGE_NODE";
if (pageMode != null && pageMode.toLowerCase().indexOf("outline") >= 0)
contentTypeId = "OUTLINE_NODE";
GenericValue thisContent = null;
try {
thisContent = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne();
if (thisContent == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentNoContentFound", UtilMisc.toMap("contentId", contentId), locale));
}
thisContent.set("contentTypeId", contentTypeId);
thisContent.store();
List<GenericValue> kids = ContentWorker.getAssociatedContent(thisContent, "from", UtilMisc.toList("SUB_CONTENT"), null, null, null);
for (GenericValue kidContent : kids) {
if (contentTypeId.equals("OUTLINE_NODE")) {
updateOutlineNodeChildren(kidContent, false, context);
} else {
updatePageNodeChildren(kidContent, context);
}
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return results;
}
public static Map<String, Object> resetToOutlineMode(DispatchContext dctx, Map<String, ? extends Object> rcontext) throws GenericServiceException{
Delegator delegator = dctx.getDelegator();
Map<String, Object> context = UtilMisc.makeMapWritable(rcontext);
Map<String, Object> results = new HashMap<String, Object>();
Locale locale = (Locale) context.get("locale");
Set<String> visitedSet = UtilGenerics.checkSet(context.get("visitedSet"));
if (visitedSet == null) {
visitedSet = new HashSet<String>();
context.put("visitedSet", visitedSet);
}
String contentId = (String)context.get("contentId");
String pageMode = (String)context.get("pageMode");
String contentTypeId = "OUTLINE_NODE";
if (pageMode != null && pageMode.toLowerCase().indexOf("page") >= 0) {
contentTypeId = "PAGE_NODE";
}
GenericValue thisContent = null;
try {
thisContent = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne();
if (thisContent == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"ContentNoContentFound", UtilMisc.toMap("contentId", contentId), locale));
}
thisContent.set("contentTypeId", "OUTLINE_NODE");
thisContent.store();
List<GenericValue> kids = ContentWorker.getAssociatedContent(thisContent, "from", UtilMisc.toList("SUB_CONTENT"), null, null, null);
for (GenericValue kidContent : kids) {
if (contentTypeId.equals("OUTLINE_NODE")) {
updateOutlineNodeChildren(kidContent, true, context);
} else {
kidContent.put("contentTypeId", "PAGE_NODE");
kidContent.store();
List<GenericValue> kids2 = ContentWorker.getAssociatedContent(kidContent, "from", UtilMisc.toList("SUB_CONTENT"), null, null, null);
for (GenericValue kidContent2 : kids2) {
updatePageNodeChildren(kidContent2, context);
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return results;
}
public static Map<String, Object> clearContentAssocViewCache(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> results = new HashMap<String, Object>();
UtilCache<?, ?> utilCache = UtilCache.findCache("entitycache.entity-list.default.ContentAssocViewFrom");
if (utilCache != null) {
utilCache.clear();
}
utilCache = UtilCache.findCache("entitycache.entity-list.default.ContentAssocViewTo");
if (utilCache != null) {
utilCache.clear();
}
return results;
}
public static Map<String, Object> clearContentAssocDataResourceViewCache(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> results = new HashMap<String, Object>();
UtilCache<?, ?> utilCache = UtilCache.findCache("entitycache.entity-list.default.ContentAssocViewDataResourceFrom");
if (utilCache != null) {
utilCache.clear();
}
utilCache = UtilCache.findCache("entitycache.entity-list.default.ContentAssocViewDataResourceTo");
if (utilCache != null) {
utilCache.clear();
}
return results;
}
public static void updatePageNodeChildren(GenericValue content, Map<String, Object> context) throws GenericEntityException {
String contentId = content.getString("contentId");
Set<String> visitedSet = UtilGenerics.checkSet(context.get("visitedSet"));
if (visitedSet == null) {
visitedSet = new HashSet<String>();
context.put("visitedSet", visitedSet);
} else {
if (visitedSet.contains(contentId)) {
Debug.logWarning("visitedSet already contains:" + contentId, module);
return;
} else {
visitedSet.add(contentId);
}
}
String newContentTypeId = "SUBPAGE_NODE";
content.put("contentTypeId", newContentTypeId);
content.store();
List<GenericValue> kids = ContentWorker.getAssociatedContent(content, "from", UtilMisc.toList("SUB_CONTENT"), null, null, null);
for (GenericValue kidContent : kids) {
updatePageNodeChildren(kidContent, context);
}
}
public static void updateOutlineNodeChildren(GenericValue content, boolean forceOutline, Map<String, Object> context) throws GenericEntityException {
String contentId = content.getString("contentId");
Set<String> visitedSet = UtilGenerics.checkSet(context.get("visitedSet"));
if (visitedSet == null) {
visitedSet = new HashSet<String>();
context.put("visitedSet", visitedSet);
} else {
if (visitedSet.contains(contentId)) {
Debug.logWarning("visitedSet already contains:" + contentId, module);
return;
} else {
visitedSet.add(contentId);
}
}
String contentTypeId = content.getString("contentTypeId");
String newContentTypeId = contentTypeId;
String dataResourceId = content.getString("dataResourceId");
Long branchCount = (Long)content.get("childBranchCount");
if (forceOutline) {
newContentTypeId = "OUTLINE_NODE";
} else if (contentTypeId == null || contentTypeId.equals("DOCUMENT")) {
if (UtilValidate.isEmpty(dataResourceId) || (branchCount != null && branchCount.intValue() > 0)) {
newContentTypeId = "OUTLINE_NODE";
} else {
newContentTypeId = "PAGE_NODE";
}
} else if (contentTypeId.equals("SUBPAGE_NODE")) {
newContentTypeId = "PAGE_NODE";
}
content.put("contentTypeId", newContentTypeId);
content.store();
if (contentTypeId == null || contentTypeId.equals("DOCUMENT") || contentTypeId.equals("OUTLINE_NODE")) {
List<GenericValue> kids = ContentWorker.getAssociatedContent(content, "from", UtilMisc.toList("SUB_CONTENT"), null, null, null);
for (GenericValue kidContent : kids) {
updateOutlineNodeChildren(kidContent, forceOutline, context);
}
}
}
public static Map<String, Object> findSubNodes(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> results = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
String contentIdTo = (String)context.get("contentId");
try {
List<GenericValue> lst = EntityQuery.use(delegator).from("ContentAssocDataResourceViewFrom")
.where("caContentIdTo", contentIdTo,
"caContentAssocTypeId", "SUB_CONTENT",
"caThruDate", null)
.orderBy("caSequenceNum", "caFromDate", "createdDate")
.queryList();
results.put("_LIST_", lst);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.toString());
}
return results;
}
public static String updateTypeAndFile(GenericValue dataResource, Map<String, Object> context) {
String retVal = null;
String mimeTypeId = (String) context.get("_imageData_contentType");
String fileName = (String) context.get("_imageData_fileName");
try {
if (UtilValidate.isNotEmpty(fileName))
dataResource.set("objectInfo", fileName);
if (UtilValidate.isNotEmpty(mimeTypeId))
dataResource.set("mimeTypeId", mimeTypeId);
dataResource.store();
} catch (GenericEntityException e) {
retVal = "Unable to update the DataResource record";
}
return retVal;
}
public static Map<String, Object> initContentChildCounts(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Locale locale = (Locale) context.get("locale");
GenericValue content = (GenericValue)context.get("content");
if (content == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentNoContentFound", UtilMisc.toMap("contentId", ""), locale));
}
Long leafCount = (Long)content.get("childLeafCount");
if (leafCount == null) {
content.set("childLeafCount", Long.valueOf(0));
}
Long branchCount = (Long)content.get("childBranchCount");
if (branchCount == null) {
content.set("childBranchCount", Long.valueOf(0));
}
return result;
}
public static Map<String, Object> incrementContentChildStats(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String contentId = (String)context.get("contentId");
String contentAssocTypeId = (String)context.get("contentAssocTypeId");
try {
GenericValue content = EntityQuery.use(delegator).from("Content").where("contentId", contentId).cache().queryOne();
if (content == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentNoContentFound", UtilMisc.toMap("contentId", contentId), locale));
}
Long leafCount = (Long)content.get("childLeafCount");
if (leafCount == null) {
leafCount = Long.valueOf(0);
}
int changeLeafCount = leafCount.intValue() + 1;
int changeBranchCount = 1;
ContentManagementWorker.updateStatsBottomUp(delegator, contentId, UtilMisc.toList(contentAssocTypeId), changeBranchCount, changeLeafCount);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> decrementContentChildStats(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String contentId = (String)context.get("contentId");
String contentAssocTypeId = (String)context.get("contentAssocTypeId");
try {
GenericValue content = EntityQuery.use(delegator).from("Content").where("contentId", contentId).cache().queryOne();
if (content == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentNoContentFound", UtilMisc.toMap("contentId", contentId), locale));
}
Long leafCount = (Long)content.get("childLeafCount");
if (leafCount == null) {
leafCount = Long.valueOf(0);
}
int changeLeafCount = -1 * leafCount.intValue() - 1;
int changeBranchCount = -1;
ContentManagementWorker.updateStatsBottomUp(delegator, contentId, UtilMisc.toList(contentAssocTypeId), changeBranchCount, changeLeafCount);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> updateContentChildStats(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
String contentId = (String)context.get("contentId");
String contentAssocTypeId = (String)context.get("contentAssocTypeId");
List<String> typeList = new LinkedList<String>();
if (UtilValidate.isNotEmpty(contentAssocTypeId)) {
typeList.add(contentAssocTypeId);
} else {
typeList = UtilMisc.toList("PUBLISH_LINK", "SUB_CONTENT");
}
try {
ContentManagementWorker.updateStatsTopDown(delegator, contentId, typeList);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> updateContentSubscription(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
String partyId = (String) context.get("partyId");
String webPubPt = (String) context.get("contentId");
String roleTypeId = (String) context.get("useRoleTypeId");
GenericValue userLogin = (GenericValue) context.get("userLogin");
Integer useTime = (Integer) context.get("useTime");
String useTimeUomId = (String) context.get("useTimeUomId");
boolean hasExistingContentRole = false;
GenericValue contentRole = null;
try {
contentRole = EntityQuery.use(delegator).from("ContentRole")
.where("partyId", partyId, "contentId", webPubPt, "roleTypeId", roleTypeId)
.orderBy("fromDate DESC")
.cache().filterByDate()
.queryFirst();
if (contentRole != null) {
hasExistingContentRole = true;
}
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
if (contentRole == null) {
contentRole = delegator.makeValue("ContentRole");
contentRole.set("contentId", webPubPt);
contentRole.set("partyId", partyId);
contentRole.set("roleTypeId", roleTypeId);
contentRole.set("fromDate", nowTimestamp);
}
Timestamp thruDate = (Timestamp) contentRole.get("thruDate");
if (thruDate == null) {
// no thruDate? start with NOW
thruDate = nowTimestamp;
} else {
// there is a thru date... if it is in the past, bring it up to NOW before adding on the time period
//don't want to penalize for skipping time, in other words if they had a subscription last year for a month and buy another month, we want that second month to start now and not last year
if (thruDate.before(nowTimestamp)) {
thruDate = nowTimestamp;
}
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(thruDate);
int field = Calendar.MONTH;
if ("TF_day".equals(useTimeUomId)) {
field = Calendar.DAY_OF_YEAR;
} else if ("TF_wk".equals(useTimeUomId)) {
field = Calendar.WEEK_OF_YEAR;
} else if ("TF_mon".equals(useTimeUomId)) {
field = Calendar.MONTH;
} else if ("TF_yr".equals(useTimeUomId)) {
field = Calendar.YEAR;
} else {
Debug.logWarning("Don't know anything about useTimeUomId [" + useTimeUomId + "], defaulting to month", module);
}
calendar.add(field, useTime.intValue());
thruDate = new Timestamp(calendar.getTimeInMillis());
contentRole.set("thruDate", thruDate);
try {
if (hasExistingContentRole) {
contentRole.store();
} else {
Map<String, Object> map = new HashMap<String, Object>();
map.put("partyId", partyId);
map.put("roleTypeId", roleTypeId);
map.put("userLogin", userLogin);
dispatcher.runSync("ensurePartyRole", map);
contentRole.create();
}
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> updateContentSubscriptionByProduct(DispatchContext dctx, Map<String, ? extends Object> rcontext) throws GenericServiceException{
Map<String, Object> context = UtilMisc.makeMapWritable(rcontext);
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
LocalDispatcher dispatcher = dctx.getDispatcher();
String productId = (String) context.get("productId");
Integer qty = (Integer) context.get("quantity");
if (qty == null) {
qty = Integer.valueOf(1);
}
Timestamp orderCreatedDate = (Timestamp) context.get("orderCreatedDate");
if (orderCreatedDate == null) {
orderCreatedDate = UtilDateTime.nowTimestamp();
}
GenericValue productContent = null;
try {
List<GenericValue> lst = EntityQuery.use(delegator).from("ProductContent")
.where("productId", productId, "productContentTypeId", "ONLINE_ACCESS")
.orderBy("purchaseFromDate", "purchaseThruDate")
.filterByDate("purchaseFromDate", "purchaseThruDate")
.cache().queryList();
List<GenericValue> listThrusOnly = EntityUtil.filterOutByCondition(lst, EntityCondition.makeCondition("purchaseThruDate", EntityOperator.EQUALS, null));
if (listThrusOnly.size() > 0) {
productContent = listThrusOnly.get(0);
} else if (lst.size() > 0) {
productContent = lst.get(0);
}
} catch (GenericEntityException e) {
Debug.logError(e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
if (productContent == null) {
String msg = UtilProperties.getMessage(resource, "ContentNoProductContentFound", UtilMisc.toMap("productId", productId), locale);
Debug.logError(msg, module);
return ServiceUtil.returnError(msg);
}
Long useTime = (Long) productContent.get("useTime");
Integer newUseTime = null;
if (UtilValidate.isNotEmpty(useTime)) {
newUseTime = Integer.valueOf(useTime.intValue() * qty.intValue());
}
context.put("useTime", newUseTime);
context.put("useTimeUomId", productContent.get("useTimeUomId"));
context.put("useRoleTypeId", productContent.get("useRoleTypeId"));
context.put("contentId", productContent.get("contentId"));
ModelService subscriptionModel = dispatcher.getDispatchContext().getModelService("updateContentSubscription");
Map<String, Object> ctx = subscriptionModel.makeValid(context, "IN");
result = dispatcher.runSync("updateContentSubscription", ctx);
return result;
}
public static Map<String, Object> updateContentSubscriptionByOrder(DispatchContext dctx, Map<String, ? extends Object> rcontext) throws GenericServiceException{
Map<String, Object> context = UtilMisc.makeMapWritable(rcontext);
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
LocalDispatcher dispatcher = dctx.getDispatcher();
String orderId = (String) context.get("orderId");
Debug.logInfo("In updateContentSubscriptionByOrder service with orderId: " + orderId, module);
GenericValue orderHeader = null;
try {
GenericValue orderRole = EntityQuery.use(delegator).from("OrderRole")
.where("orderId", orderId, "roleTypeId", "END_USER_CUSTOMER")
.queryFirst();
if (orderRole != null) {
String partyId = (String) orderRole.get("partyId");
context.put("partyId", partyId);
} else {
String msg = "No OrderRole found for orderId:" + orderId;
return ServiceUtil.returnFailure(msg);
}
orderHeader = EntityQuery.use(delegator).from("OrderHeader").where("orderId", orderId).queryOne();
if (orderHeader == null) {
String msg = UtilProperties.getMessage(resource, "ContentNoOrderHeaderFound", UtilMisc.toMap("orderId", orderId), locale);
return ServiceUtil.returnError(msg);
}
Timestamp orderCreatedDate = (Timestamp) orderHeader.get("orderDate");
context.put("orderCreatedDate", orderCreatedDate);
List<GenericValue> orderItemList = orderHeader.getRelated("OrderItem", null, null, false);
ModelService subscriptionModel = dispatcher.getDispatchContext().getModelService("updateContentSubscriptionByProduct");
for (GenericValue orderItem : orderItemList) {
BigDecimal qty = orderItem.getBigDecimal("quantity");
String productId = (String) orderItem.get("productId");
long productContentCount = EntityQuery.use(delegator).from("ProductContent")
.where("productId", productId, "productContentTypeId", "ONLINE_ACCESS")
.filterByDate().queryCount();
if (productContentCount > 0) {
context.put("productId", productId);
context.put("quantity", Integer.valueOf(qty.intValue()));
Map<String, Object> ctx = subscriptionModel.makeValid(context, "IN");
dispatcher.runSync("updateContentSubscriptionByProduct", ctx);
}
}
} catch (GenericEntityException e) {
Debug.logError(e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> followNodeChildren(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException{
Map<String, Object> result = null;
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Security security = dctx.getSecurity();
GenericValue userLogin = (GenericValue)context.get("userLogin");
Locale locale = (Locale) context.get("locale");
if (!security.hasEntityPermission("CONTENTMGR", "_ADMIN", userLogin)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentPermissionNotGranted", locale));
}
String contentId = (String)context.get("contentId");
String serviceName = (String)context.get("serviceName");
String contentAssocTypeId = (String)context.get("contentAssocTypeId");
List<String> contentAssocTypeIdList = new LinkedList<String>();
if (UtilValidate.isNotEmpty(contentAssocTypeId)) {
contentAssocTypeIdList = StringUtil.split(contentAssocTypeId, "|");
}
if (contentAssocTypeIdList.size() == 0) {
contentAssocTypeIdList.add("SUB_CONTENT");
}
Map<String, Object> ctx = new HashMap<String, Object>();
ctx.put("userLogin", userLogin);
ctx.put("contentAssocTypeIdList", contentAssocTypeIdList);
try {
GenericValue content = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne();
result = followNodeChildrenMethod(content, dispatcher, serviceName, ctx);
} catch (GenericEntityException e) {
Debug.logError(e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
return result;
}
public static Map<String, Object> followNodeChildrenMethod(GenericValue content, LocalDispatcher dispatcher, String serviceName, Map<String, Object> context) throws GenericEntityException, GenericServiceException {
Map<String, Object> result = null;
String contentId = content.getString("contentId");
List<String> contentAssocTypeIdList = UtilGenerics.checkList(context.get("contentAssocTypeIdList"));
Locale locale = (Locale) context.get("locale");
Set<String> visitedSet = UtilGenerics.checkSet(context.get("visitedSet"));
if (visitedSet == null) {
visitedSet = new HashSet<String>();
context.put("visitedSet", visitedSet);
} else {
if (visitedSet.contains(contentId)) {
Debug.logWarning("visitedSet already contains:" + contentId, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentVisitedSet", locale) + contentId);
} else {
visitedSet.add(contentId);
}
}
GenericValue userLogin = (GenericValue)context.get("userLogin");
result = dispatcher.runSync(serviceName, UtilMisc.toMap("content", content, "userLogin", userLogin));
List<GenericValue> kids = ContentWorker.getAssociatedContent(content, "from", contentAssocTypeIdList, null, null, null);
for (GenericValue kidContent : kids) {
followNodeChildrenMethod(kidContent, dispatcher, serviceName, context);
}
return result;
}
public static Map<String, Object> persistContentWithRevision(DispatchContext dctx, Map<String, ? extends Object> context) {
Map<String, Object> result = null;
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
GenericValue dataResource = null;
String masterRevisionContentId = (String)context.get("masterRevisionContentId");
String oldDataResourceId = (String)context.get("drDataResourceId");
if (UtilValidate.isEmpty(oldDataResourceId)) {
oldDataResourceId = (String)context.get("dataResourceId");
}
if (UtilValidate.isNotEmpty(oldDataResourceId)) {
try {
dataResource = EntityQuery.use(delegator).from("DataResource").where("dataResourceId", oldDataResourceId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
}
try {
ModelService persistContentAndAssocModel = dispatcher.getDispatchContext().getModelService("persistContentAndAssoc");
Map<String, Object> ctx = persistContentAndAssocModel.makeValid(context, "IN");
if (dataResource != null) {
ctx.remove("dataResourceId");
ctx.remove("drDataResourceId");
}
result = dispatcher.runSync("persistContentAndAssoc", ctx);
String errorMsg = ServiceUtil.getErrorMessage(result);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
String contentId = (String)result.get("contentId");
List<String> parentList = new LinkedList<String>();
if (UtilValidate.isEmpty(masterRevisionContentId)) {
Map<String, Object> traversMap = new HashMap<String, Object>();
traversMap.put("contentId", contentId);
traversMap.put("direction", "To");
traversMap.put("contentAssocTypeId", "COMPDOC_PART");
Map<String, Object> traversResult = dispatcher.runSync("traverseContent", traversMap);
parentList = UtilGenerics.checkList(traversResult.get("parentList"));
} else {
parentList.add(masterRevisionContentId);
}
// Update ContentRevision and ContentRevisonItem
Map<String, Object> contentRevisionMap = new HashMap<String, Object>();
contentRevisionMap.put("itemContentId", contentId);
contentRevisionMap.put("newDataResourceId", result.get("dataResourceId"));
contentRevisionMap.put("oldDataResourceId", oldDataResourceId);
// need committedByPartyId
for (int i=0; i < parentList.size(); i++) {
String thisContentId = parentList.get(i);
contentRevisionMap.put("contentId", thisContentId);
result = dispatcher.runSync("persistContentRevisionAndItem", contentRevisionMap);
errorMsg = ServiceUtil.getErrorMessage(result);
if (UtilValidate.isNotEmpty(errorMsg)) {
return ServiceUtil.returnError(errorMsg);
}
}
} catch (GenericServiceException e) {
Debug.logError(e.toString(), module);
return ServiceUtil.returnError(e.toString());
}
return result;
}
}