| /******************************************************************************* |
| * 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.sql.Timestamp; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpSession; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.GeneralException; |
| import org.apache.ofbiz.base.util.StringUtil; |
| import org.apache.ofbiz.base.util.UtilGenerics; |
| import org.apache.ofbiz.base.util.UtilHttp; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.base.util.collections.LifoSet; |
| import org.apache.ofbiz.content.content.ContentServicesComplex; |
| import org.apache.ofbiz.entity.Delegator; |
| import org.apache.ofbiz.entity.GenericEntity; |
| import org.apache.ofbiz.entity.GenericEntityException; |
| import org.apache.ofbiz.entity.GenericPK; |
| 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.util.EntityQuery; |
| import org.apache.ofbiz.entity.util.EntityUtil; |
| import org.apache.ofbiz.entityext.permission.EntityPermissionChecker; |
| import org.apache.ofbiz.minilang.MiniLangException; |
| import org.apache.ofbiz.security.Security; |
| |
| |
| /** |
| * ContentManagementWorker Class |
| */ |
| public final class ContentManagementWorker { |
| |
| public static final String module = ContentManagementWorker.class.getName(); |
| private static Map<String, GenericValue> cachedWebSitePublishPoints = new HashMap<String, GenericValue>(); |
| private static Map<String, Map<String, Object>> cachedStaticValues = new HashMap<String, Map<String,Object>>(); |
| |
| private ContentManagementWorker() {} |
| |
| public static void mruAdd(HttpServletRequest request, GenericEntity pk, String suffix) { |
| HttpSession session = request.getSession(); |
| mruAdd(session, pk); |
| } |
| |
| public static void mruAdd(HttpServletRequest request, GenericEntity pk) { |
| HttpSession session = request.getSession(); |
| mruAdd(session, pk); |
| } |
| |
| public static void mruAdd(HttpSession session, GenericEntity pk) { |
| if (pk == null) { |
| return; |
| } |
| |
| Map<String, LifoSet<Object>> lookupCaches = UtilGenerics.checkMap(session.getAttribute("lookupCaches")); |
| if (lookupCaches == null) { |
| lookupCaches = new HashMap<String, LifoSet<Object>>(); |
| session.setAttribute("lookupCaches", lookupCaches); |
| } |
| String entityName = pk.getEntityName(); |
| mruAddByEntityName(entityName, pk, lookupCaches); |
| } |
| |
| /** |
| * Makes an entry in the "most recently used" cache. It picks the cache |
| * by the entity name and builds a signature from the primary key values. |
| * |
| * @param entityName |
| * @param lookupCaches |
| * @param pk either a GenericValue or GenericPK - populated |
| */ |
| public static void mruAddByEntityName(String entityName, GenericEntity pk, Map<String, LifoSet<Object>> lookupCaches) { |
| String cacheEntityName = entityName; |
| LifoSet<Object> lkupCache = lookupCaches.get(cacheEntityName); |
| if (lkupCache == null) { |
| lkupCache = new LifoSet<Object>(); |
| lookupCaches.put(cacheEntityName, lkupCache); |
| } |
| lkupCache.add(pk.getPrimaryKey()); |
| if (Debug.infoOn()) Debug.logInfo("in mruAddByEntityName, entityName:" + entityName + " lifoSet.size()" + lkupCache.size(), module); |
| } |
| |
| public static Iterator<Object> mostRecentlyViewedIterator(String entityName, Map<String, LifoSet<Object>> lookupCaches) { |
| String cacheEntityName = entityName; |
| LifoSet<Object> lkupCache = lookupCaches.get(cacheEntityName); |
| if (lkupCache == null) { |
| lkupCache = new LifoSet<Object>(); |
| lookupCaches.put(cacheEntityName, lkupCache); |
| } |
| |
| Iterator<Object> mrvIterator = lkupCache.iterator(); |
| return mrvIterator; |
| } |
| |
| |
| /** |
| * Builds a string signature from a GenericValue or GenericPK. |
| * |
| * @param pk either a populated GenericValue or GenericPK. |
| * @param suffix a string that can be used to distinguish the signature (probably not used). |
| */ |
| public static String buildPKSig(GenericEntity pk, String suffix) { |
| StringBuilder sig = new StringBuilder(""); |
| Collection<String> keyColl = pk.getPrimaryKey().getAllKeys(); |
| List<String> keyList = UtilMisc.makeListWritable(keyColl); |
| Collections.sort(keyList); |
| for (String ky : keyList) { |
| String val = (String)pk.get(ky); |
| if (UtilValidate.isNotEmpty(val)) { |
| if (sig.length() > 0) sig.append("_"); |
| sig.append(val); |
| } |
| } |
| if (UtilValidate.isNotEmpty(suffix)) { |
| if (sig.length() > 0) sig.append("_"); |
| sig.append(suffix); |
| } |
| return sig.toString(); |
| } |
| |
| public static void setCurrentEntityMap(HttpServletRequest request, GenericEntity ent) { |
| String entityName = ent.getEntityName(); |
| setCurrentEntityMap(request, entityName, ent); |
| } |
| |
| public static void setCurrentEntityMap(HttpServletRequest request, String entityName, GenericEntity ent) { |
| HttpSession session = request.getSession(); |
| Map<String, GenericEntity> currentEntityMap = UtilGenerics.checkMap(session.getAttribute("currentEntityMap")); |
| if (currentEntityMap == null) { |
| currentEntityMap = new HashMap<String, GenericEntity>(); |
| session.setAttribute("currentEntityMap", currentEntityMap); |
| } |
| currentEntityMap.put(entityName, ent); |
| } |
| |
| public static String getFromSomewhere(String name, Map<String, Object> paramMap, HttpServletRequest request, Map<String, Object> context) { |
| String ret = null; |
| if (paramMap != null) { |
| ret = (String)paramMap.get(name); |
| } |
| if (UtilValidate.isEmpty(ret)) { |
| Object obj = request.getAttribute(name); |
| if (obj != null) { |
| ret = obj.toString(); |
| } else { |
| obj = context.get(name); |
| if (obj != null) { |
| ret = obj.toString(); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| public static void getCurrentValue(HttpServletRequest request, Delegator delegator) { |
| HttpSession session = request.getSession(); |
| Map<String, GenericPK> currentEntityMap = UtilGenerics.checkMap(session.getAttribute("currentEntityMap")); |
| if (currentEntityMap == null) { |
| currentEntityMap = new HashMap<String, GenericPK>(); |
| session.setAttribute("currentEntityMap", currentEntityMap); |
| } |
| Map<String, Object> paramMap = UtilHttp.getParameterMap(request); |
| String entityName = (String)paramMap.get("entityName"); |
| if (UtilValidate.isEmpty(entityName)) { |
| entityName = (String)request.getAttribute("entityName"); |
| } |
| GenericPK cachedPK = null; |
| if (UtilValidate.isNotEmpty(entityName)) { |
| cachedPK = currentEntityMap.get(entityName); |
| } |
| getCurrentValueWithCachedPK(request, delegator, cachedPK, entityName); |
| GenericPK currentPK = (GenericPK)request.getAttribute("currentPK"); |
| currentEntityMap.put(entityName, currentPK); |
| } |
| |
| public static void getCurrentValueWithCachedPK(HttpServletRequest request, Delegator delegator, GenericPK cachedPK, String entityName) { |
| Map<String, Object> paramMap = UtilHttp.getParameterMap(request); |
| // Build the primary key that may have been passed in as key values |
| GenericValue v = delegator.makeValue(entityName); |
| GenericPK passedPK = v.getPrimaryKey(); |
| Collection<String> keyColl = passedPK.getAllKeys(); |
| for (String attrName : keyColl) { |
| String attrVal = (String)request.getAttribute(attrName); |
| if (UtilValidate.isEmpty(attrVal)) { |
| attrVal = (String)paramMap.get(attrName); |
| } |
| if (UtilValidate.isNotEmpty(attrVal)) { |
| passedPK.put(attrName,attrVal); |
| } |
| } |
| |
| // If a full passed primary key exists, it takes precedence over a cached key |
| // I cannot determine if the key testing utils of GenericEntity take into account |
| // whether or not a field is populated. |
| boolean useCached = false; |
| boolean usePassed = true; |
| if (cachedPK != null) { |
| useCached = true; |
| keyColl = cachedPK.getPrimaryKey().getAllKeys(); |
| for (String ky : keyColl) { |
| String sCached = null; |
| String sPassed = null; |
| Object oPassed = null; |
| Object oCached = null; |
| oPassed = passedPK.get(ky); |
| if (oPassed != null) { |
| sPassed = oPassed.toString(); |
| if (UtilValidate.isEmpty(sPassed)) { |
| // If any part of passed key is not available, it can't be used |
| usePassed = false; |
| } else { |
| oCached = cachedPK.get(ky); |
| if (oCached != null) { |
| sCached = oCached.toString(); |
| if (UtilValidate.isEmpty(sCached)) { |
| useCached = false; |
| } else { |
| } |
| } else { |
| useCached = false; |
| } |
| } |
| } else { |
| usePassed = false; |
| } |
| } |
| } |
| |
| GenericPK currentPK = null; |
| if (usePassed && useCached) { |
| currentPK = passedPK; |
| } else if (usePassed && !useCached) { |
| currentPK = passedPK; |
| } else if (!usePassed && useCached) { |
| currentPK = cachedPK; |
| } |
| |
| if (currentPK != null) { |
| request.setAttribute("currentPK", currentPK); |
| GenericValue currentValue = null; |
| try { |
| currentValue = EntityQuery.use(delegator).from(currentPK.getEntityName()).where(currentPK).queryOne(); |
| } catch (GenericEntityException e) { |
| } |
| request.setAttribute("currentValue", currentValue); |
| } |
| |
| } |
| |
| public static List<String []> getPermittedPublishPoints(Delegator delegator, List<GenericValue> allPublishPoints, GenericValue userLogin, Security security, String permittedAction, String permittedOperations, String passedRoles) throws GeneralException { |
| List<String []> permittedPublishPointList = new LinkedList<String[]>(); |
| |
| // Check that user has permission to admin sites |
| for (GenericValue webSitePP : allPublishPoints) { |
| String contentId = (String)webSitePP.get("contentId"); |
| String templateTitle = (String)webSitePP.get("templateTitle"); |
| GenericValue content = delegator.makeValue("Content", UtilMisc.toMap("contentId", contentId)); |
| String statusId = null; |
| String entityAction = permittedAction; |
| if (entityAction == null) { |
| entityAction = "_ADMIN"; |
| } |
| List<String> passedPurposes = UtilMisc.toList("ARTICLE"); |
| List<String> roles = StringUtil.split(passedRoles, "|"); |
| List<String> targetOperationList = new LinkedList<String>(); |
| if (UtilValidate.isEmpty(permittedOperations)) { |
| targetOperationList.add("CONTENT" + entityAction); |
| } else { |
| targetOperationList = StringUtil.split(permittedOperations, "|"); |
| } |
| Map<String, Object> results = null; |
| results = EntityPermissionChecker.checkPermission(content, statusId, userLogin, passedPurposes, targetOperationList, roles, delegator, security, entityAction); |
| String permissionStatus = (String)results.get("permissionStatus"); |
| if (permissionStatus != null && permissionStatus.equalsIgnoreCase("granted")) { |
| String [] arr = {contentId,templateTitle}; |
| permittedPublishPointList.add(arr); |
| } |
| } |
| return permittedPublishPointList; |
| } |
| |
| /** |
| Returns a list of WebSitePublishPoint entities that are children of parentPubPt |
| The name should be "getAllTopLevelPublishPoints" or "getAllChildPublishPoints" |
| |
| @param parentPubPt The parent publish point. |
| */ |
| public static List<GenericValue> getAllPublishPoints(Delegator delegator, String parentPubPt) throws GeneralException { |
| List<GenericValue> relatedPubPts = null; |
| try { |
| relatedPubPts = EntityQuery.use(delegator).from("ContentAssoc") |
| .where("contentIdTo", parentPubPt, "contentAssocTypeId", "SUBSITE") |
| .cache().queryList(); |
| } catch (GenericEntityException e) { |
| throw new GeneralException(e.getMessage()); |
| } |
| List<GenericValue> allPublishPoints = new LinkedList<GenericValue>(); |
| GenericValue webSitePublishPoint = null; |
| for (GenericValue contentAssoc : relatedPubPts) { |
| String pub = (String)contentAssoc.get("contentId"); |
| webSitePublishPoint = getWebSitePublishPoint(delegator, pub, false); |
| allPublishPoints.add(webSitePublishPoint); |
| } |
| return allPublishPoints; |
| } |
| |
| public static Map<String, GenericValue> getPublishPointMap(Delegator delegator, String pubPtId) throws GeneralException { |
| List<GenericValue> publishPointList = getAllPublishPoints(delegator, pubPtId); |
| Map<String, GenericValue> publishPointMap = new HashMap<String, GenericValue>(); |
| for (GenericValue webSitePublishPoint : publishPointList) { |
| String pub = (String)webSitePublishPoint.get("contentId"); |
| publishPointMap.put(pub, webSitePublishPoint); |
| } |
| return publishPointMap; |
| } |
| |
| |
| public static void getAllPublishPointMap(Delegator delegator, String pubPtId, Map<String, GenericValue> publishPointMap) throws GeneralException { |
| List<GenericValue> publishPointList = getAllPublishPoints(delegator, pubPtId); |
| for (GenericValue webSitePublishPoint : publishPointList) { |
| String pub = (String)webSitePublishPoint.get("contentId"); |
| publishPointMap.put(pub, webSitePublishPoint); |
| getAllPublishPointMap(delegator, pub, publishPointMap); |
| } |
| } |
| |
| public static Map<String, GenericValue> getPublishPointMap(Delegator delegator, List<GenericValue> publishPointList) { |
| Map<String, GenericValue> publishPointMap = new HashMap<String, GenericValue>(); |
| for (GenericValue webSitePublishPoint : publishPointList) { |
| String pub = (String)webSitePublishPoint.get("contentId"); |
| publishPointMap.put(pub, webSitePublishPoint); |
| } |
| return publishPointMap; |
| } |
| |
| public static List<Map<String, Object>> getStaticValues(Delegator delegator, String parentPlaceholderId, List<String []> permittedPublishPointList) throws GeneralException { |
| List<GenericValue> assocValueList = null; |
| try { |
| assocValueList = EntityQuery.use(delegator).from("Content").where("contentTypeId", parentPlaceholderId).cache().queryList(); |
| } catch (GenericEntityException e) { |
| throw new GeneralException(e.getMessage()); |
| } |
| |
| List<Map<String, Object>> staticValueList = new LinkedList<Map<String,Object>>(); |
| int counter = 0; |
| for (GenericValue content : assocValueList) { |
| String contentId = (String)content.get("contentId"); |
| String contentName = (String)content.get("contentName"); |
| String description = (String)content.get("description"); |
| Map<String, Object> map = new HashMap<String, Object>(); |
| map.put("contentId", contentId); |
| map.put("contentName", contentName); |
| map.put("description", description); |
| for (String [] publishPointArray : permittedPublishPointList) { |
| String publishPointId = publishPointArray[0]; |
| List<GenericValue> contentAssocList = content.getRelated("ToContentAssoc", UtilMisc.toMap("contentId", publishPointId), null, false); |
| List<GenericValue> filteredList = EntityUtil.filterByDate(contentAssocList); |
| if (filteredList.size() > 0) { |
| map.put(publishPointId, "Y"); |
| GenericValue assoc = filteredList.get(0); |
| Timestamp fromDate = (Timestamp)assoc.get("fromDate"); |
| map.put(publishPointId + "FromDate", fromDate); |
| } else { |
| map.put(publishPointId, "N"); |
| } |
| } |
| staticValueList.add(map); |
| counter++; |
| } |
| return staticValueList; |
| } |
| |
| public static GenericValue getWebSitePublishPoint(Delegator delegator, String contentId) throws GenericEntityException { |
| return getWebSitePublishPoint(delegator, contentId, false); |
| } |
| |
| public static GenericValue getWebSitePublishPoint(Delegator delegator, String contentId, boolean ignoreCache) throws GenericEntityException { |
| GenericValue webSitePublishPoint = null; |
| if (!ignoreCache) |
| webSitePublishPoint = cachedWebSitePublishPoints.get(contentId); |
| |
| if (webSitePublishPoint == null) { |
| webSitePublishPoint = EntityQuery.use(delegator).from("WebSitePublishPoint").where("contentId", contentId).queryOne(); |
| // If no webSitePublishPoint exists, still try to look for parent by making a dummy value |
| if (webSitePublishPoint == null) { |
| webSitePublishPoint = delegator.makeValue("WebSitePublishPoint", UtilMisc.toMap("contentId", contentId)); |
| } |
| webSitePublishPoint = overrideWebSitePublishPoint(delegator, webSitePublishPoint); |
| cachedWebSitePublishPoints.put(contentId, webSitePublishPoint); |
| } |
| return webSitePublishPoint; |
| } |
| |
| public static GenericValue overrideWebSitePublishPoint(Delegator delegator, GenericValue passedValue) throws GenericEntityException { |
| String contentId = passedValue.getString("contentId"); |
| GenericValue webSitePublishPoint = passedValue; |
| String contentIdTo = getParentWebSitePublishPointId(delegator, contentId); |
| if (contentIdTo != null) { |
| webSitePublishPoint = EntityQuery.use(delegator).from("WebSitePublishPoint").where("contentId", contentIdTo).cache().queryOne(); |
| if (webSitePublishPoint != null) { |
| webSitePublishPoint = GenericValue.create(webSitePublishPoint); |
| webSitePublishPoint = overrideWebSitePublishPoint(delegator, webSitePublishPoint); |
| webSitePublishPoint.setNonPKFields(passedValue, false); |
| webSitePublishPoint.setPKFields(passedValue, false); |
| passedValue.setNonPKFields(webSitePublishPoint); |
| } |
| } |
| return webSitePublishPoint; |
| } |
| |
| public static GenericValue getParentWebSitePublishPointValue(Delegator delegator, String contentId) throws GenericEntityException { |
| |
| String contentIdTo = getParentWebSitePublishPointId(delegator, contentId); |
| GenericValue content = EntityQuery.use(delegator).from("Content").where("contentId", contentIdTo).cache().queryOne(); |
| return content; |
| } |
| |
| public static String getParentWebSitePublishPointId(Delegator delegator, String contentId) throws GenericEntityException { |
| String contentIdTo = null; |
| GenericValue contentAssoc = EntityQuery.use(delegator).from("ContentAssoc") |
| .where("contentId", contentId, "contentAssocTypeId", "SUBSITE") |
| .filterByDate().cache().queryFirst(); |
| if (contentAssoc != null) { |
| contentIdTo = contentAssoc.getString("contentIdTo"); |
| } |
| return contentIdTo; |
| } |
| |
| public static GenericValue getStaticValue(Delegator delegator, String parentPlaceholderId, String webSitePublishPointId, boolean ignoreCache) throws GenericEntityException { |
| GenericValue webSitePublishPoint = null; |
| if (!ignoreCache) { |
| Map<String, Object> subStaticValueMap = cachedStaticValues.get(parentPlaceholderId); |
| if (subStaticValueMap == null) { |
| subStaticValueMap = new HashMap<String, Object>(); |
| cachedStaticValues.put(parentPlaceholderId, subStaticValueMap); |
| } |
| } |
| |
| return webSitePublishPoint; |
| } |
| |
| public static List<Object []> getPublishedLinks(Delegator delegator, String targContentId, String rootPubId, GenericValue userLogin, Security security, String permittedAction, String permittedOperations , String passedRoles) throws GeneralException { |
| // Set up one map with all the top-level publish points (to which only one sub point can be attached to) |
| // and another map (publishPointMapAll) that points to one of the top-level points. |
| List<GenericValue> allPublishPointList = getAllPublishPoints(delegator, rootPubId); |
| List<String []> publishPointList = getPermittedPublishPoints(delegator, allPublishPointList, userLogin, security , permittedAction, permittedOperations, passedRoles); |
| Map<String, Object> publishPointMap = new HashMap<String, Object>(); |
| Map<String, Object> publishPointMapAll = new HashMap<String, Object>(); |
| for (String [] arr : publishPointList) { |
| String contentId = arr[0]; |
| String description = arr[1]; |
| List<Object []> subPointList = new LinkedList<Object[]>(); |
| Object nullObj = null; |
| Object [] subArr = {contentId, subPointList, description, nullObj}; |
| publishPointMap.put(contentId, subArr); |
| publishPointMapAll.put(contentId, contentId); |
| List<GenericValue> subPublishPointList = getAllPublishPoints(delegator, contentId); |
| for (GenericValue webSitePublishPoint2 : subPublishPointList) { |
| String contentId2 = (String)webSitePublishPoint2.get("contentId"); |
| String description2 = (String)webSitePublishPoint2.get("templateTitle"); |
| publishPointMapAll.put(contentId2, contentId); |
| Timestamp obj = null; |
| Object [] subArr2 = {contentId2, description2, obj}; |
| subPointList.add(subArr2); |
| } |
| } |
| List<GenericValue> assocValueList = null; |
| try { |
| assocValueList = EntityQuery.use(delegator).from("ContentAssoc") |
| .where("contentId", targContentId, "contentAssocTypeId", "PUBLISH_LINK") |
| .filterByDate().cache().queryList(); |
| } catch (GenericEntityException e) { |
| throw new GeneralException(e.getMessage()); |
| } |
| for (GenericValue contentAssoc : assocValueList) { |
| String contentIdTo = contentAssoc.getString("contentIdTo"); |
| String topContentId = (String)publishPointMapAll.get(contentIdTo); |
| Object [] subArr = (Object [])publishPointMap.get(topContentId); |
| if (contentIdTo.equals(topContentId)) { |
| subArr[3] = contentAssoc.get("fromDate"); |
| } else { |
| if (subArr != null) { |
| List<Object []> subPointList = UtilGenerics.checkList(subArr[1]); |
| Iterator<Object []> it5 = subPointList.iterator(); |
| Object [] subArr2 = null; |
| while (it5.hasNext()) { |
| subArr2 = it5.next(); |
| String contentId5 = (String)subArr2[0]; |
| if (contentId5.equals(contentIdTo)) |
| break; |
| } |
| subArr2[2] = contentAssoc.get("fromDate"); |
| } |
| } |
| } |
| |
| List<Object []> publishedLinkList = new LinkedList<Object[]>(); |
| for (String contentId : publishPointMap.keySet()) { |
| Object [] subPointArr = (Object [])publishPointMap.get(contentId); |
| publishedLinkList.add(subPointArr); |
| } |
| return publishedLinkList; |
| } |
| |
| public static GenericValue getAuthorContent(Delegator delegator, String contentId) { |
| GenericValue authorContent = null; |
| try { |
| List<String> assocTypes = UtilMisc.toList("AUTHOR"); |
| List<String> contentTypes = null; |
| Map<String, Object> results = ContentServicesComplex.getAssocAndContentAndDataResourceCacheMethod(delegator, contentId, null, "To", null, null, assocTypes, contentTypes, Boolean.TRUE, null, null); |
| List<GenericValue> valueList = UtilGenerics.checkList(results.get("entityList")); |
| if (valueList.size() > 0) { |
| GenericValue value = valueList.get(0); |
| authorContent = delegator.makeValue("Content"); |
| authorContent.setPKFields(value); |
| authorContent.setNonPKFields(value); |
| } |
| } catch (GenericEntityException e) { |
| } catch (MiniLangException e2) { |
| } |
| |
| return authorContent; |
| } |
| |
| public static List<String []> getPermittedDepartmentPoints(Delegator delegator, List<GenericValue> allDepartmentPoints, GenericValue userLogin, Security security, String permittedAction, String permittedOperations, String passedRoles) throws GeneralException { |
| List<String []> permittedDepartmentPointList = new LinkedList<String[]>(); |
| |
| // Check that user has permission to admin sites |
| for (GenericValue content : allDepartmentPoints) { |
| String contentId = (String)content.get("contentId"); |
| String contentName = (String)content.get("contentName"); |
| String statusId = null; |
| String entityAction = permittedAction; |
| if (entityAction == null) |
| entityAction = "_ADMIN"; |
| List<String> passedPurposes = UtilMisc.<String>toList("ARTICLE"); |
| List<String> roles = StringUtil.split(passedRoles, "|"); |
| List<String> targetOperationList = new LinkedList<String>(); |
| if (UtilValidate.isEmpty(permittedOperations)) { |
| targetOperationList.add("CONTENT" + entityAction); |
| } else { |
| targetOperationList = StringUtil.split(permittedOperations, "|"); |
| } |
| Map<String, Object> results = null; |
| results = EntityPermissionChecker.checkPermission(content, statusId, userLogin, passedPurposes, targetOperationList, roles, delegator, security, entityAction); |
| String permissionStatus = (String)results.get("permissionStatus"); |
| if (permissionStatus != null && permissionStatus.equalsIgnoreCase("granted")) { |
| String [] arr = {contentId,contentName}; |
| permittedDepartmentPointList.add(arr); |
| } |
| } |
| return permittedDepartmentPointList; |
| } |
| |
| /** |
| Returns a list of "department" (having ContentAssoc of type "DEPARTMENT") |
| Content entities that are children of parentPubPt |
| |
| @param parentPubPt The parent publish point. |
| */ |
| public static List<GenericValue> getAllDepartmentContent(Delegator delegator, String parentPubPt) throws GeneralException { |
| List<GenericValue> relatedPubPts = null; |
| try { |
| relatedPubPts = EntityQuery.use(delegator).from("ContentAssoc") |
| .where("contentIdTo", parentPubPt, "contentAssocTypeId", "DEPARTMENT") |
| .cache().queryList(); |
| |
| } catch (GenericEntityException e) { |
| throw new GeneralException(e.getMessage()); |
| } |
| List<GenericValue> allDepartmentPoints = new LinkedList<GenericValue>(); |
| GenericValue departmentContent = null; |
| for (GenericValue contentAssoc : relatedPubPts) { |
| String pub = (String)contentAssoc.get("contentId"); |
| departmentContent = EntityQuery.use(delegator).from("Content").where("contentId", pub).cache().queryOne(); |
| allDepartmentPoints.add(departmentContent); |
| } |
| return allDepartmentPoints; |
| } |
| |
| public static String getUserName(HttpServletRequest request, String userLoginId) throws GenericEntityException { |
| String userName = null; |
| Delegator delegator = (Delegator)request.getAttribute("delegator"); |
| GenericValue userLogin = EntityQuery.use(delegator).from("UserLogin").where("userLoginId", userLoginId).cache().queryOne(); |
| GenericValue person = userLogin.getRelatedOne("Person", true); |
| userName = person.getString("firstName") + " " + person.getString("lastName"); |
| return userName; |
| } |
| |
| public static int updateStatsTopDown(Delegator delegator, String contentId, List<String> typeList) throws GenericEntityException { |
| int subLeafCount = 0; |
| GenericValue thisContent = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne(); |
| if (thisContent == null) |
| throw new RuntimeException("No entity found for id=" + contentId); |
| |
| List<EntityCondition> conditionMain = new ArrayList<EntityCondition>(); |
| conditionMain.add(EntityCondition.makeCondition("contentIdTo", contentId)); |
| if (typeList.size() > 0) { |
| conditionMain.add(EntityCondition.makeCondition("contentAssocTypeId", EntityOperator.IN, typeList)); |
| } |
| List<GenericValue> contentAssocs = EntityQuery.use(delegator).from("ContentAssoc").where(conditionMain) |
| .filterByDate().cache().queryList(); |
| for (GenericValue contentAssoc : contentAssocs) { |
| String subContentId = contentAssoc.getString("contentId"); |
| subLeafCount += updateStatsTopDown(delegator, subContentId, typeList); |
| } |
| |
| // If no children, count this as a leaf |
| if (subLeafCount == 0) |
| subLeafCount = 1; |
| thisContent.put("childBranchCount", Long.valueOf(contentAssocs.size())); |
| thisContent.put("childLeafCount", Long.valueOf(subLeafCount)); |
| thisContent.store(); |
| |
| return subLeafCount; |
| } |
| |
| public static void updateStatsBottomUp(Delegator delegator, String contentId, List<String> typeList, int branchChangeAmount, int leafChangeAmount) throws GenericEntityException { |
| GenericValue thisContent = EntityQuery.use(delegator).from("Content").where("contentId", contentId).queryOne(); |
| if (thisContent == null) |
| throw new RuntimeException("No entity found for id=" + contentId); |
| |
| List<GenericValue> contentAssocs = EntityQuery.use(delegator).from("ContentAssoc") |
| .where(EntityCondition.makeCondition("contentAssocTypeId", EntityOperator.IN, typeList), |
| EntityCondition.makeCondition("contentId", EntityOperator.EQUALS, contentId)) |
| .cache().filterByDate().queryList(); |
| for (GenericValue contentAssoc : contentAssocs) { |
| String contentIdTo = contentAssoc.getString("contentIdTo"); |
| GenericValue contentTo = EntityQuery.use(delegator).from("Content").where("contentId", contentIdTo).queryOne(); |
| int intLeafCount = 0; |
| Long leafCount = (Long)contentTo.get("childLeafCount"); |
| if (leafCount != null) { |
| intLeafCount = leafCount.intValue(); |
| } |
| contentTo.set("childLeafCount", Long.valueOf(intLeafCount + leafChangeAmount)); |
| |
| if (branchChangeAmount != 0) { |
| int intBranchCount = 0; |
| Long branchCount = (Long)contentTo.get("childBranchCount"); |
| if (branchCount != null) { |
| intBranchCount = branchCount.intValue(); |
| } |
| contentTo.set("childBranchCount", Long.valueOf(intBranchCount + branchChangeAmount)); |
| } |
| contentTo.store(); |
| updateStatsBottomUp(delegator, contentIdTo, typeList, 0, leafChangeAmount); |
| } |
| } |
| } |