| /******************************************************************************* |
| * 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.data; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.StringWriter; |
| import java.io.Writer; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.nio.ByteBuffer; |
| import java.sql.Timestamp; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.TreeMap; |
| |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpSession; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.transform.TransformerException; |
| |
| import org.apache.commons.fileupload.FileItem; |
| import org.apache.commons.fileupload.FileUploadException; |
| import org.apache.commons.fileupload.disk.DiskFileItemFactory; |
| import org.apache.commons.fileupload.servlet.ServletFileUpload; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.IOUtils; |
| import org.apache.tika.Tika; |
| import org.apache.ofbiz.base.location.FlexibleLocation; |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.FileUtil; |
| import org.apache.ofbiz.base.util.GeneralException; |
| import org.apache.ofbiz.base.util.StringUtil; |
| import org.apache.ofbiz.base.util.StringUtil.StringWrapper; |
| import org.apache.ofbiz.base.util.UtilGenerics; |
| import org.apache.ofbiz.base.util.UtilHttp; |
| import org.apache.ofbiz.base.util.UtilIO; |
| 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.UtilXml; |
| import org.apache.ofbiz.base.util.collections.MapStack; |
| import org.apache.ofbiz.base.util.template.FreeMarkerWorker; |
| import org.apache.ofbiz.base.util.template.XslTransform; |
| import org.apache.ofbiz.common.email.NotificationServices; |
| import org.apache.ofbiz.content.content.UploadContentAndImage; |
| import org.apache.ofbiz.entity.Delegator; |
| import org.apache.ofbiz.entity.GenericEntityException; |
| import org.apache.ofbiz.entity.GenericValue; |
| import org.apache.ofbiz.entity.util.EntityQuery; |
| import org.apache.ofbiz.entity.util.EntityUtilProperties; |
| import org.apache.ofbiz.service.GenericServiceException; |
| import org.apache.ofbiz.service.LocalDispatcher; |
| import org.apache.ofbiz.widget.model.ModelScreen; |
| import org.apache.ofbiz.widget.model.ScreenFactory; |
| import org.apache.ofbiz.widget.renderer.ScreenRenderer; |
| import org.apache.ofbiz.widget.renderer.ScreenStringRenderer; |
| import org.apache.ofbiz.widget.renderer.macro.MacroScreenRenderer; |
| import org.w3c.dom.Document; |
| import org.xml.sax.SAXException; |
| |
| import freemarker.template.TemplateException; |
| |
| /** |
| * DataResourceWorker Class |
| */ |
| public class DataResourceWorker implements org.apache.ofbiz.widget.content.DataResourceWorkerInterface { |
| |
| public static final String module = DataResourceWorker.class.getName(); |
| public static final String err_resource = "ContentErrorUiLabels"; |
| |
| /** |
| * Traverses the DataCategory parent/child structure and put it in categoryNode. Returns non-null error string if there is an error. |
| * @param depth The place on the categoryTypesIds to start collecting. |
| * @param getAll Indicates that all descendants are to be gotten. Used as "true" to populate an |
| * indented select list. |
| */ |
| public static String getDataCategoryMap(Delegator delegator, int depth, Map<String, Object> categoryNode, List<String> categoryTypeIds, boolean getAll) throws GenericEntityException { |
| String errorMsg = null; |
| String parentCategoryId = (String) categoryNode.get("id"); |
| String currentDataCategoryId = null; |
| int sz = categoryTypeIds.size(); |
| |
| // The categoryTypeIds has the most senior types at the end, so it is necessary to |
| // work backwards. As "depth" is incremented, that is the effect. |
| // The convention for the topmost type is "ROOT". |
| if (depth >= 0 && (sz - depth) > 0) { |
| currentDataCategoryId = categoryTypeIds.get(sz - depth - 1); |
| } |
| |
| // Find all the categoryTypes that are children of the categoryNode. |
| List<GenericValue> categoryValues = EntityQuery.use(delegator).from("DataCategory") |
| .where("parentCategoryId", parentCategoryId) |
| .cache().queryList(); |
| categoryNode.put("count", Integer.valueOf(categoryValues.size())); |
| List<Map<String, Object>> subCategoryIds = new LinkedList<Map<String,Object>>(); |
| for (GenericValue category : categoryValues) { |
| String id = (String) category.get("dataCategoryId"); |
| String categoryName = (String) category.get("categoryName"); |
| Map<String, Object> newNode = new HashMap<String, Object>(); |
| newNode.put("id", id); |
| newNode.put("name", categoryName); |
| errorMsg = getDataCategoryMap(delegator, depth + 1, newNode, categoryTypeIds, getAll); |
| if (errorMsg != null) |
| break; |
| subCategoryIds.add(newNode); |
| } |
| |
| // The first two parentCategoryId test just make sure that the first level of children |
| // is gotten. This is a hack to make them available for display, but a more correct |
| // approach should be formulated. |
| // The "getAll" switch makes sure all descendants make it into the tree, if true. |
| // The other test is to only get all the children if the "leaf" node where all the |
| // children of the leaf are wanted for expansion. |
| if (parentCategoryId == null |
| || parentCategoryId.equals("ROOT") |
| || (currentDataCategoryId != null && currentDataCategoryId.equals(parentCategoryId)) |
| || getAll) { |
| categoryNode.put("kids", subCategoryIds); |
| } |
| return errorMsg; |
| } |
| |
| /** |
| * Finds the parents of DataCategory entity and puts them in a list, the start entity at the top. |
| */ |
| public static void getDataCategoryAncestry(Delegator delegator, String dataCategoryId, List<String> categoryTypeIds) throws GenericEntityException { |
| categoryTypeIds.add(dataCategoryId); |
| GenericValue dataCategoryValue = EntityQuery.use(delegator).from("DataCategory").where("dataCategoryId", dataCategoryId).queryOne(); |
| if (dataCategoryValue == null) |
| return; |
| String parentCategoryId = (String) dataCategoryValue.get("parentCategoryId"); |
| if (parentCategoryId != null) { |
| getDataCategoryAncestry(delegator, parentCategoryId, categoryTypeIds); |
| } |
| } |
| |
| /** |
| * Takes a DataCategory structure and builds a list of maps, one value (id) is the dataCategoryId value and the other is an indented string suitable for |
| * use in a drop-down pick list. |
| */ |
| public static void buildList(Map<String, Object> nd, List<Map<String, Object>> lst, int depth) { |
| String id = (String) nd.get("id"); |
| String nm = (String) nd.get("name"); |
| String spc = ""; |
| for (int i = 0; i < depth; i++) |
| spc += " "; |
| Map<String, Object> map = new HashMap<String, Object>(); |
| map.put("dataCategoryId", id); |
| map.put("categoryName", spc + nm); |
| if (id != null && !id.equals("ROOT") && !id.equals("")) { |
| lst.add(map); |
| } |
| List<Map<String, Object>> kids = UtilGenerics.checkList(nd.get("kids")); |
| for (Map<String, Object> kidNode : kids) { |
| buildList(kidNode, lst, depth + 1); |
| } |
| } |
| |
| /** |
| * Uploads image data from a form and stores it in ImageDataResource. Expects key data in a field identified by the "idField" value and the binary data |
| * to be in a field id'd by uploadField. |
| */ |
| // TODO: This method is not used and should be removed. amb |
| public static String uploadAndStoreImage(HttpServletRequest request, String idField, String uploadField) { |
| ServletFileUpload fu = new ServletFileUpload(new DiskFileItemFactory(10240, FileUtil.getFile("runtime/tmp"))); |
| List<FileItem> lst = null; |
| Locale locale = UtilHttp.getLocale(request); |
| |
| try { |
| lst = UtilGenerics.checkList(fu.parseRequest(request)); |
| } catch (FileUploadException e) { |
| request.setAttribute("_ERROR_MESSAGE_", e.toString()); |
| return "error"; |
| } |
| |
| if (lst.size() == 0) { |
| String errMsg = UtilProperties.getMessage(DataResourceWorker.err_resource, "dataResourceWorker.no_files_uploaded", locale); |
| request.setAttribute("_ERROR_MESSAGE_", errMsg); |
| Debug.logWarning("[DataEvents.uploadImage] No files uploaded", module); |
| return "error"; |
| } |
| |
| // This code finds the idField and the upload FileItems |
| FileItem fi = null; |
| FileItem imageFi = null; |
| String imageFileName = null; |
| Map<String, Object> passedParams = new HashMap<String, Object>(); |
| HttpSession session = request.getSession(); |
| GenericValue userLogin = (GenericValue)session.getAttribute("userLogin"); |
| passedParams.put("userLogin", userLogin); |
| byte[] imageBytes = null; |
| for (int i = 0; i < lst.size(); i++) { |
| fi = lst.get(i); |
| String fieldName = fi.getFieldName(); |
| if (fi.isFormField()) { |
| String fieldStr = fi.getString(); |
| passedParams.put(fieldName, fieldStr); |
| } else if (fieldName.startsWith("imageData")) { |
| imageFi = fi; |
| imageBytes = imageFi.get(); |
| passedParams.put(fieldName, imageBytes); |
| imageFileName = imageFi.getName(); |
| passedParams.put("drObjectInfo", imageFileName); |
| if (Debug.infoOn()) Debug.logInfo("[UploadContentAndImage]imageData: " + imageBytes.length, module); |
| } |
| } |
| |
| if (imageBytes != null && imageBytes.length > 0) { |
| String mimeType = getMimeTypeFromImageFileName(imageFileName); |
| if (UtilValidate.isNotEmpty(mimeType)) { |
| passedParams.put("drMimeTypeId", mimeType); |
| try { |
| String returnMsg = UploadContentAndImage.processContentUpload(passedParams, "", request); |
| if (returnMsg.equals("error")) { |
| return "error"; |
| } |
| } catch (GenericServiceException e) { |
| request.setAttribute("_ERROR_MESSAGE_", e.getMessage()); |
| return "error"; |
| } |
| } else { |
| request.setAttribute("_ERROR_MESSAGE_", "mimeType is empty."); |
| return "error"; |
| } |
| } |
| return "success"; |
| } |
| |
| public static String getMimeTypeFromImageFileName(String imageFileName) { |
| String mimeType = null; |
| if (UtilValidate.isEmpty(imageFileName)) |
| return mimeType; |
| |
| int pos = imageFileName.lastIndexOf("."); |
| if (pos < 0) |
| return mimeType; |
| |
| String suffix = imageFileName.substring(pos + 1); |
| String suffixLC = suffix.toLowerCase(); |
| if (suffixLC.equals("jpg")) |
| mimeType = "image/jpeg"; |
| else |
| mimeType = "image/" + suffixLC; |
| |
| return mimeType; |
| } |
| |
| /** |
| * callDataResourcePermissionCheck Formats data for a call to the checkContentPermission service. |
| */ |
| public static String callDataResourcePermissionCheck(Delegator delegator, LocalDispatcher dispatcher, Map<String, Object> context) { |
| Map<String, Object> permResults = callDataResourcePermissionCheckResult(delegator, dispatcher, context); |
| String permissionStatus = (String) permResults.get("permissionStatus"); |
| return permissionStatus; |
| } |
| |
| /** |
| * callDataResourcePermissionCheck Formats data for a call to the checkContentPermission service. |
| */ |
| public static Map<String, Object> callDataResourcePermissionCheckResult(Delegator delegator, LocalDispatcher dispatcher, Map<String, Object> context) { |
| |
| Map<String, Object> permResults = new HashMap<String, Object>(); |
| String skipPermissionCheck = (String) context.get("skipPermissionCheck"); |
| if (Debug.infoOn()) Debug.logInfo("in callDataResourcePermissionCheckResult, skipPermissionCheck:" + skipPermissionCheck,""); |
| |
| if (UtilValidate.isEmpty(skipPermissionCheck) |
| || (!"true".equalsIgnoreCase(skipPermissionCheck) && !"granted".equalsIgnoreCase(skipPermissionCheck))) { |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| Map<String, Object> serviceInMap = new HashMap<String, Object>(); |
| serviceInMap.put("userLogin", userLogin); |
| serviceInMap.put("targetOperationList", context.get("targetOperationList")); |
| serviceInMap.put("contentPurposeList", context.get("contentPurposeList")); |
| serviceInMap.put("entityOperation", context.get("entityOperation")); |
| |
| // It is possible that permission to work with DataResources will be controlled |
| // by an external Content entity. |
| String ownerContentId = (String) context.get("ownerContentId"); |
| if (UtilValidate.isNotEmpty(ownerContentId)) { |
| try { |
| GenericValue content = EntityQuery.use(delegator).from("Content").where("contentId", ownerContentId).queryOne(); |
| if (content != null) |
| serviceInMap.put("currentContent", content); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "e.getMessage()", "ContentServices"); |
| } |
| } |
| try { |
| permResults = dispatcher.runSync("checkContentPermission", serviceInMap); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, "Problem checking permissions", "ContentServices"); |
| } |
| } else { |
| permResults.put("permissionStatus", "granted"); |
| } |
| return permResults; |
| } |
| |
| /** |
| * Gets image data from ImageDataResource and returns it as a byte array. |
| */ |
| public static byte[] acquireImage(Delegator delegator, String dataResourceId) throws GenericEntityException { |
| |
| byte[] b = null; |
| GenericValue dataResource = EntityQuery.use(delegator).from("DataResource").where("dataResourceId", dataResourceId).cache().queryOne(); |
| if (dataResource == null) |
| return b; |
| |
| b = acquireImage(delegator, dataResource); |
| return b; |
| } |
| |
| public static byte[] acquireImage(Delegator delegator, GenericValue dataResource) throws GenericEntityException { |
| byte[] b = null; |
| String dataResourceId = dataResource.getString("dataResourceId"); |
| GenericValue imageDataResource = EntityQuery.use(delegator).from("ImageDataResource").where("dataResourceId", dataResourceId).queryOne(); |
| if (imageDataResource != null) { |
| b = imageDataResource.getBytes("imageData"); |
| } |
| return b; |
| } |
| |
| public static String getMimeType(GenericValue dataResource) { |
| String mimeTypeId = null; |
| if (dataResource != null) { |
| mimeTypeId = (String) dataResource.get("mimeTypeId"); |
| if (UtilValidate.isEmpty(mimeTypeId)) { |
| String fileName = (String) dataResource.get("objectInfo"); |
| if (fileName != null && fileName.indexOf('.') > -1) { |
| String fileExtension = fileName.substring(fileName.lastIndexOf('.') + 1); |
| if (UtilValidate.isNotEmpty(fileExtension)) { |
| GenericValue ext = null; |
| try { |
| ext = dataResource.getDelegator().findOne("FileExtension", |
| UtilMisc.toMap("fileExtensionId", fileExtension), false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| if (ext != null) { |
| mimeTypeId = ext.getString("mimeTypeId"); |
| } |
| } |
| } |
| |
| // check one last time |
| if (UtilValidate.isEmpty(mimeTypeId)) { |
| // use a default mime type |
| mimeTypeId = "application/octet-stream"; |
| } |
| } |
| } |
| return mimeTypeId; |
| } |
| |
| public static String getMimeTypeWithByteBuffer(java.nio.ByteBuffer buffer) throws IOException { |
| byte[] b = buffer.array(); |
| |
| Tika tika = new Tika(); |
| return tika.detect(b); |
| } |
| |
| public static String buildRequestPrefix(Delegator delegator, Locale locale, String webSiteId, String https) { |
| Map<String, Object> prefixValues = new HashMap<String, Object>(); |
| String prefix; |
| |
| NotificationServices.setBaseUrl(delegator, webSiteId, prefixValues); |
| if (https != null && https.equalsIgnoreCase("true")) { |
| prefix = (String) prefixValues.get("baseSecureUrl"); |
| } else { |
| prefix = (String) prefixValues.get("baseUrl"); |
| } |
| if (UtilValidate.isEmpty(prefix)) { |
| if (https != null && https.equalsIgnoreCase("true")) { |
| prefix = UtilProperties.getMessage("content", "baseSecureUrl", locale); |
| } else { |
| prefix = UtilProperties.getMessage("content", "baseUrl", locale); |
| } |
| } |
| |
| return prefix; |
| } |
| |
| public static File getContentFile(String dataResourceTypeId, String objectInfo, String contextRoot) throws GeneralException, FileNotFoundException{ |
| File file = null; |
| |
| if (dataResourceTypeId.equals("LOCAL_FILE") || dataResourceTypeId.equals("LOCAL_FILE_BIN")) { |
| file = FileUtil.getFile(objectInfo); |
| if (!file.exists()) { |
| throw new FileNotFoundException("No file found: " + (objectInfo)); |
| } |
| if (!file.isAbsolute()) { |
| throw new GeneralException("File (" + objectInfo + ") is not absolute"); |
| } |
| } else if (dataResourceTypeId.equals("OFBIZ_FILE") || dataResourceTypeId.equals("OFBIZ_FILE_BIN")) { |
| String prefix = System.getProperty("ofbiz.home"); |
| |
| String sep = ""; |
| if (objectInfo.indexOf("/") != 0 && prefix.lastIndexOf("/") != (prefix.length() - 1)) { |
| sep = "/"; |
| } |
| file = FileUtil.getFile(prefix + sep + objectInfo); |
| if (!file.exists()) { |
| throw new FileNotFoundException("No file found: " + (prefix + sep + objectInfo)); |
| } |
| } else if (dataResourceTypeId.equals("CONTEXT_FILE") || dataResourceTypeId.equals("CONTEXT_FILE_BIN")) { |
| if (UtilValidate.isEmpty(contextRoot)) { |
| throw new GeneralException("Cannot find CONTEXT_FILE with an empty context root!"); |
| } |
| |
| String sep = ""; |
| if (objectInfo.indexOf("/") != 0 && contextRoot.lastIndexOf("/") != (contextRoot.length() - 1)) { |
| sep = "/"; |
| } |
| file = FileUtil.getFile(contextRoot + sep + objectInfo); |
| if (!file.exists()) { |
| throw new FileNotFoundException("No file found: " + (contextRoot + sep + objectInfo)); |
| } |
| } |
| |
| return file; |
| } |
| |
| |
| public static String getDataResourceMimeType(Delegator delegator, String dataResourceId, GenericValue view) throws GenericEntityException { |
| |
| String mimeType = null; |
| if (view != null) |
| mimeType = view.getString("drMimeTypeId"); |
| if (UtilValidate.isEmpty(mimeType) && UtilValidate.isNotEmpty(dataResourceId)) { |
| GenericValue dataResource = EntityQuery.use(delegator).from("DataResource").where("dataResourceId", dataResourceId).cache().queryOne(); |
| mimeType = dataResource.getString("mimeTypeId"); |
| |
| } |
| return mimeType; |
| } |
| |
| public static String getDataResourceContentUploadPath() { |
| return getDataResourceContentUploadPath(true); |
| } |
| |
| public static String getDataResourceContentUploadPath(boolean absolute) { |
| String initialPath = UtilProperties.getPropertyValue("content", "content.upload.path.prefix"); |
| double maxFiles = UtilProperties.getPropertyNumber("content", "content.upload.max.files"); |
| if (maxFiles < 1) { |
| maxFiles = 250; |
| } |
| |
| return getDataResourceContentUploadPath(initialPath, maxFiles, absolute); |
| } |
| |
| public static String getDataResourceContentUploadPath(Delegator delegator, boolean absolute) { |
| String initialPath = EntityUtilProperties.getPropertyValue("content", "content.upload.path.prefix", delegator); |
| double maxFiles = UtilProperties.getPropertyNumber("content", "content.upload.max.files"); |
| if (maxFiles < 1) { |
| maxFiles = 250; |
| } |
| |
| return getDataResourceContentUploadPath(initialPath, maxFiles, absolute); |
| } |
| |
| public static String getDataResourceContentUploadPath(String initialPath, double maxFiles) { |
| return getDataResourceContentUploadPath(initialPath, maxFiles, true); |
| } |
| |
| /** |
| * Handles creating sub-directories for file storage; using a max number of files per directory |
| * @param initialPath the top level location where all files should be stored |
| * @param maxFiles the max number of files to place in a directory |
| * @return the absolute path to the directory where the file should be placed |
| */ |
| public static String getDataResourceContentUploadPath(String initialPath, double maxFiles, boolean absolute) { |
| String ofbizHome = System.getProperty("ofbiz.home"); |
| |
| if (!initialPath.startsWith("/")) { |
| initialPath = "/" + initialPath; |
| } |
| |
| // descending comparator |
| Comparator<Object> desc = new Comparator<Object>() { |
| public int compare(Object o1, Object o2) { |
| if (((Long) o1).longValue() > ((Long) o2).longValue()) { |
| return -1; |
| } else if (((Long) o1).longValue() < ((Long) o2).longValue()) { |
| return 1; |
| } |
| return 0; |
| } |
| }; |
| |
| // check for the latest subdirectory |
| String parentDir = ofbizHome + initialPath; |
| File parent = FileUtil.getFile(parentDir); |
| TreeMap<Long, File> dirMap = new TreeMap<Long, File>(desc); |
| if (parent.exists()) { |
| File[] subs = parent.listFiles(); |
| for (int i = 0; i < subs.length; i++) { |
| if (subs[i].isDirectory()) { |
| dirMap.put(Long.valueOf(subs[i].lastModified()), subs[i]); |
| } |
| } |
| } else { |
| // if the parent doesn't exist; create it now |
| boolean created = parent.mkdir(); |
| if (!created) { |
| Debug.logWarning("Unable to create top level upload directory [" + parentDir + "].", module); |
| } |
| } |
| |
| // first item in map is the most current directory |
| File latestDir = null; |
| if (UtilValidate.isNotEmpty(dirMap)) { |
| latestDir = dirMap.values().iterator().next(); |
| if (latestDir != null) { |
| File[] dirList = latestDir.listFiles(); |
| if (dirList.length >= maxFiles) { |
| latestDir = makeNewDirectory(parent); |
| } |
| } |
| } else { |
| latestDir = makeNewDirectory(parent); |
| } |
| |
| Debug.logInfo("Directory Name : " + latestDir.getName(), module); |
| if (absolute) { |
| return latestDir.getAbsolutePath().replace('\\','/'); |
| } else { |
| return initialPath + "/" + latestDir.getName(); |
| |
| } |
| } |
| |
| private static File makeNewDirectory(File parent) { |
| File latestDir = null; |
| boolean newDir = false; |
| while (!newDir) { |
| latestDir = new File(parent, "" + System.currentTimeMillis()); |
| if (!latestDir.exists()) { |
| latestDir.mkdir(); |
| newDir = true; |
| } |
| } |
| return latestDir; |
| } |
| |
| // ------------------------------------- |
| // DataResource rendering methods |
| // ------------------------------------- |
| |
| public static void clearAssociatedRenderCache(Delegator delegator, String dataResourceId) throws GeneralException { |
| if (dataResourceId == null) { |
| throw new GeneralException("Cannot clear dataResource related cache for a null dataResourceId"); |
| } |
| |
| GenericValue dataResource = EntityQuery.use(delegator).from("DataResource").where("dataResourceId", dataResourceId).cache().queryOne(); |
| if (dataResource != null) { |
| String dataTemplateTypeId = dataResource.getString("dataTemplateTypeId"); |
| if ("FTL".equals(dataTemplateTypeId)) { |
| FreeMarkerWorker.clearTemplateFromCache("delegator:" + delegator.getDelegatorName() + ":DataResource:" + dataResourceId); |
| } |
| } |
| } |
| |
| public static String renderDataResourceAsText(Delegator delegator, String dataResourceId, Map<String, Object> templateContext, |
| Locale locale, String targetMimeTypeId, boolean cache) throws GeneralException, IOException { |
| Writer writer = new StringWriter(); |
| renderDataResourceAsText(delegator, dataResourceId, writer, templateContext, locale, targetMimeTypeId, cache, null); |
| return writer.toString(); |
| } |
| |
| public static String renderDataResourceAsText(Delegator delegator, String dataResourceId, Appendable out, |
| Map<String, Object> templateContext, Locale locale, String targetMimeTypeId, boolean cache) throws GeneralException, IOException { |
| renderDataResourceAsText(delegator, dataResourceId, out, templateContext, locale, targetMimeTypeId, cache, null); |
| return out.toString(); |
| } |
| |
| public static void renderDataResourceAsText(Delegator delegator, String dataResourceId, Appendable out, |
| Map<String, Object> templateContext, Locale locale, String targetMimeTypeId, boolean cache, List<GenericValue> webAnalytics) throws GeneralException, IOException { |
| if (dataResourceId == null) { |
| throw new GeneralException("Cannot lookup data resource with for a null dataResourceId"); |
| } |
| if (templateContext == null) { |
| templateContext = new HashMap<String, Object>(); |
| } |
| if (UtilValidate.isEmpty(targetMimeTypeId)) { |
| targetMimeTypeId = "text/html"; |
| } |
| if (locale == null) { |
| locale = Locale.getDefault(); |
| } |
| |
| // if the target mimeTypeId is not a text type, throw an exception |
| if (!targetMimeTypeId.startsWith("text/")) { |
| throw new GeneralException("The desired mime-type is not a text type, cannot render as text: " + targetMimeTypeId); |
| } |
| |
| // get the data resource object |
| GenericValue dataResource = EntityQuery.use(delegator).from("DataResource") |
| .where("dataResourceId", dataResourceId) |
| .cache(cache).queryOne(); |
| |
| if (dataResource == null) { |
| throw new GeneralException("No data resource object found for dataResourceId: [" + dataResourceId + "]"); |
| } |
| |
| // a data template attached to the data resource |
| String dataTemplateTypeId = dataResource.getString("dataTemplateTypeId"); |
| |
| // no template; or template is NONE; render the data |
| if (UtilValidate.isEmpty(dataTemplateTypeId) || "NONE".equals(dataTemplateTypeId)) { |
| DataResourceWorker.writeDataResourceText(dataResource, targetMimeTypeId, locale, templateContext, delegator, out, cache); |
| } else { |
| // a template is defined; render the template first |
| templateContext.put("mimeTypeId", targetMimeTypeId); |
| |
| // FTL template |
| if ("FTL".equals(dataTemplateTypeId)) { |
| try { |
| // get the template data for rendering |
| String templateText = getDataResourceText(dataResource, targetMimeTypeId, locale, templateContext, delegator, cache); |
| |
| // if use web analytics. |
| if (UtilValidate.isNotEmpty(webAnalytics)) { |
| StringBuffer newTemplateText = new StringBuffer(templateText); |
| String webAnalyticsCode = "<script language=\"JavaScript\" type=\"text/javascript\">"; |
| for (GenericValue webAnalytic : webAnalytics) { |
| StringWrapper wrapString = StringUtil.wrapString((String) webAnalytic.get("webAnalyticsCode")); |
| webAnalyticsCode += wrapString.toString(); |
| } |
| webAnalyticsCode += "</script>"; |
| newTemplateText.insert(templateText.lastIndexOf("</head>"), webAnalyticsCode); |
| templateText = newTemplateText.toString(); |
| } |
| |
| // render the FTL template |
| boolean useTemplateCache = cache && !UtilProperties.getPropertyAsBoolean("content", "disable.ftl.template.cache", false); |
| Timestamp lastUpdatedStamp = dataResource.getTimestamp("lastUpdatedStamp"); |
| FreeMarkerWorker.renderTemplateFromString("delegator:" + delegator.getDelegatorName() + ":DataResource:" + dataResourceId, templateText, templateContext, out, lastUpdatedStamp.getTime(), useTemplateCache); |
| } catch (TemplateException e) { |
| throw new GeneralException("Error rendering FTL template", e); |
| } |
| |
| } else if ("XSLT".equals(dataTemplateTypeId)) { |
| File sourceFileLocation = null; |
| File targetFileLocation = new File(System.getProperty("ofbiz.home")+"/runtime/tempfiles/docbook.css"); |
| if (templateContext.get("visualThemeId") != null) { |
| Map<String, Object> layoutSettings = UtilGenerics.checkMap(templateContext.get("layoutSettings")); |
| List<String> docbookStyleSheets = UtilGenerics.checkList(layoutSettings.get("VT_DOCBOOKSTYLESHEET")); |
| String docbookStyleLocation = docbookStyleSheets.get(0); |
| sourceFileLocation = new File(System.getProperty("ofbiz.home")+"/themes"+docbookStyleLocation); |
| } |
| if (sourceFileLocation != null && sourceFileLocation.exists()) { |
| UtilMisc.copyFile(sourceFileLocation,targetFileLocation); |
| } else { |
| String defaultVisualThemeId = EntityUtilProperties.getPropertyValue("general", "VISUAL_THEME", delegator); |
| if (defaultVisualThemeId != null) { |
| GenericValue themeValue = EntityQuery.use(delegator).from("VisualThemeResource").where("visualThemeId", defaultVisualThemeId, "resourceTypeEnumId", "VT_DOCBOOKSTYLESHEET", "sequenceId", "01").cache().queryOne(); |
| sourceFileLocation = new File(System.getProperty("ofbiz.home") + "/themes" + themeValue.get("resourceValue")); |
| UtilMisc.copyFile(sourceFileLocation,targetFileLocation); |
| } |
| } |
| // get the template data for rendering |
| String templateLocation = DataResourceWorker.getContentFile(dataResource.getString("dataResourceTypeId"), dataResource.getString("objectInfo"), (String) templateContext.get("contextRoot")).toString(); |
| // render the XSLT template and file |
| String outDoc = null; |
| try { |
| outDoc = XslTransform.renderTemplate(templateLocation, (String) templateContext.get("docFile")); |
| } catch (TransformerException c) { |
| Debug.logError("XSL TransformerException: " + c.getMessage(), module); |
| } |
| out.append(outDoc); |
| |
| // Screen Widget template |
| } else if ("SCREEN_COMBINED".equals(dataTemplateTypeId)) { |
| try { |
| MapStack<String> context = MapStack.create(templateContext); |
| context.put("locale", locale); |
| // prepare the map for preRenderedContent |
| String textData = (String) context.get("textData"); |
| if (UtilValidate.isNotEmpty(textData)) { |
| Map<String, Object> prc = new HashMap<String, Object>(); |
| String mapKey = (String) context.get("mapKey"); |
| if (mapKey != null) { |
| prc.put(mapKey, mapKey); |
| } |
| prc.put("body", textData); // used for default screen defs |
| context.put("preRenderedContent", prc); |
| } |
| // get the screen renderer; or create a new one |
| ScreenRenderer screens = (ScreenRenderer) context.get("screens"); |
| if (screens == null) { |
| // TODO: replace "screen" to support dynamic rendering of different output |
| ScreenStringRenderer screenStringRenderer = new MacroScreenRenderer(EntityUtilProperties.getPropertyValue("widget", "screen.name", delegator), EntityUtilProperties.getPropertyValue("widget", "screen.screenrenderer", delegator)); |
| screens = new ScreenRenderer(out, context, screenStringRenderer); |
| screens.getContext().put("screens", screens); |
| } |
| // render the screen |
| ModelScreen modelScreen = null; |
| ScreenStringRenderer renderer = screens.getScreenStringRenderer(); |
| String combinedName = dataResource.getString("objectInfo"); |
| if ("URL_RESOURCE".equals(dataResource.getString("dataResourceTypeId")) && UtilValidate.isNotEmpty(combinedName) && combinedName.startsWith("component://")) { |
| modelScreen = ScreenFactory.getScreenFromLocation(combinedName); |
| } else { // stored in a single file, long or short text |
| Document screenXml = UtilXml.readXmlDocument(getDataResourceText(dataResource, targetMimeTypeId, locale, templateContext, delegator, cache), true, true); |
| Map<String, ModelScreen> modelScreenMap = ScreenFactory.readScreenDocument(screenXml, "DataResourceId: " + dataResource.getString("dataResourceId")); |
| if (UtilValidate.isNotEmpty(modelScreenMap)) { |
| Map.Entry<String, ModelScreen> entry = modelScreenMap.entrySet().iterator().next(); // get first entry, only one screen allowed per file |
| modelScreen = entry.getValue(); |
| } |
| } |
| if (UtilValidate.isNotEmpty(modelScreen)) { |
| modelScreen.renderScreenString(out, context, renderer); |
| } else { |
| throw new GeneralException("The dataResource file [" + dataResourceId + "] could not be found"); |
| } |
| } catch (SAXException e) { |
| throw new GeneralException("Error rendering Screen template", e); |
| } catch (ParserConfigurationException e) { |
| throw new GeneralException("Error rendering Screen template", e); |
| } catch (TemplateException e) { |
| throw new GeneralException("Error creating Screen renderer", e); |
| } |
| } else { |
| throw new GeneralException("The dataTemplateTypeId [" + dataTemplateTypeId + "] is not yet supported"); |
| } |
| } |
| } |
| |
| // ---------------------------- |
| // Data Resource Data Gathering |
| // ---------------------------- |
| |
| public static String getDataResourceText(GenericValue dataResource, String mimeTypeId, Locale locale, Map<String, Object> context, |
| Delegator delegator, boolean cache) throws IOException, GeneralException { |
| Writer out = new StringWriter(); |
| writeDataResourceText(dataResource, mimeTypeId, locale, context, delegator, out, cache); |
| return out.toString(); |
| } |
| |
| public static void writeDataResourceText(GenericValue dataResource, String mimeTypeId, Locale locale, Map<String, Object> templateContext, |
| Delegator delegator, Appendable out, boolean cache) throws IOException, GeneralException { |
| Map<String, Object> context = UtilGenerics.checkMap(templateContext.get("context")); |
| if (context == null) { |
| context = new HashMap<String, Object>(); |
| } |
| String webSiteId = (String) templateContext.get("webSiteId"); |
| if (UtilValidate.isEmpty(webSiteId)) { |
| if (context != null) |
| webSiteId = (String) context.get("webSiteId"); |
| } |
| |
| String https = (String) templateContext.get("https"); |
| if (UtilValidate.isEmpty(https)) { |
| if (context != null) |
| https = (String) context.get("https"); |
| } |
| |
| String rootDir = (String) templateContext.get("rootDir"); |
| if (UtilValidate.isEmpty(rootDir)) { |
| if (context != null) |
| rootDir = (String) context.get("rootDir"); |
| } |
| |
| String dataResourceId = dataResource.getString("dataResourceId"); |
| String dataResourceTypeId = dataResource.getString("dataResourceTypeId"); |
| |
| // default type |
| if (UtilValidate.isEmpty(dataResourceTypeId)) { |
| dataResourceTypeId = "SHORT_TEXT"; |
| } |
| |
| // text types |
| if ("SHORT_TEXT".equals(dataResourceTypeId) || "LINK".equals(dataResourceTypeId)) { |
| String text = dataResource.getString("objectInfo"); |
| writeText(dataResource, text, templateContext, mimeTypeId, locale, out); |
| } else if ("ELECTRONIC_TEXT".equals(dataResourceTypeId)) { |
| GenericValue electronicText = EntityQuery.use(delegator).from("ElectronicText") |
| .where("dataResourceId", dataResourceId) |
| .cache(cache).queryOne(); |
| if (electronicText != null) { |
| String text = electronicText.getString("textData"); |
| writeText(dataResource, text, templateContext, mimeTypeId, locale, out); |
| } |
| |
| // object types |
| } else if (dataResourceTypeId.endsWith("_OBJECT")) { |
| String text = (String) dataResource.get("dataResourceId"); |
| writeText(dataResource, text, templateContext, mimeTypeId, locale, out); |
| |
| // resource type |
| } else if (dataResourceTypeId.equals("URL_RESOURCE")) { |
| String text = null; |
| URL url = FlexibleLocation.resolveLocation(dataResource.getString("objectInfo")); |
| |
| if (url.getHost() != null) { // is absolute |
| InputStream in = url.openStream(); |
| int c; |
| StringWriter sw = new StringWriter(); |
| while ((c = in.read()) != -1) { |
| sw.write(c); |
| } |
| sw.close(); |
| text = sw.toString(); |
| } else { |
| String prefix = DataResourceWorker.buildRequestPrefix(delegator, locale, webSiteId, https); |
| String sep = ""; |
| if (url.toString().indexOf("/") != 0 && prefix.lastIndexOf("/") != (prefix.length() - 1)) { |
| sep = "/"; |
| } |
| String fixedUrlStr = prefix + sep + url.toString(); |
| URL fixedUrl = new URL(fixedUrlStr); |
| text = (String) fixedUrl.getContent(); |
| } |
| out.append(text); |
| |
| // file types |
| } else if (dataResourceTypeId.endsWith("_FILE_BIN")) { |
| writeText(dataResource, dataResourceId, templateContext, mimeTypeId, locale, out); |
| } else if (dataResourceTypeId.endsWith("_FILE")) { |
| String dataResourceMimeTypeId = dataResource.getString("mimeTypeId"); |
| String objectInfo = dataResource.getString("objectInfo"); |
| |
| if (dataResourceMimeTypeId == null || dataResourceMimeTypeId.startsWith("text")) { |
| renderFile(dataResourceTypeId, objectInfo, rootDir, out); |
| } else { |
| writeText(dataResource, dataResourceId, templateContext, mimeTypeId, locale, out); |
| } |
| } else { |
| throw new GeneralException("The dataResourceTypeId [" + dataResourceTypeId + "] is not supported in renderDataResourceAsText"); |
| } |
| } |
| |
| public static void writeText(GenericValue dataResource, String textData, Map<String, Object> context, String targetMimeTypeId, Locale locale, Appendable out) throws GeneralException, IOException { |
| String dataResourceMimeTypeId = dataResource.getString("mimeTypeId"); |
| Delegator delegator = dataResource.getDelegator(); |
| |
| // assume HTML as data resource data |
| if (UtilValidate.isEmpty(dataResourceMimeTypeId)) { |
| dataResourceMimeTypeId = "text/html"; |
| } |
| |
| // assume HTML for target |
| if (UtilValidate.isEmpty(targetMimeTypeId)) { |
| targetMimeTypeId = "text/html"; |
| } |
| |
| // we can only render text |
| if (!targetMimeTypeId.startsWith("text")) { |
| throw new GeneralException("Method writeText() only supports rendering text content : " + targetMimeTypeId + " is not supported"); |
| } |
| |
| if ("text/html".equals(targetMimeTypeId)) { |
| // get the default mime type template |
| GenericValue mimeTypeTemplate = EntityQuery.use(delegator).from("MimeTypeHtmlTemplate").where("mimeTypeId", dataResourceMimeTypeId).cache().queryOne(); |
| |
| if (mimeTypeTemplate != null && mimeTypeTemplate.get("templateLocation") != null) { |
| // prepare the context |
| Map<String, Object> mimeContext = new HashMap<String, Object>(); |
| mimeContext.putAll(context); |
| mimeContext.put("dataResource", dataResource); |
| mimeContext.put("textData", textData); |
| |
| String mimeString = DataResourceWorker.renderMimeTypeTemplate(mimeTypeTemplate, mimeContext); |
| if (mimeString != null) { |
| out.append(mimeString); |
| } |
| } else { |
| if (textData != null) { |
| out.append(textData); |
| } |
| } |
| } else { |
| out.append(textData); |
| } |
| } |
| |
| public static String renderMimeTypeTemplate(GenericValue mimeTypeTemplate, Map<String, Object> context) throws GeneralException, IOException { |
| String location = mimeTypeTemplate.getString("templateLocation"); |
| StringWriter writer = new StringWriter(); |
| try { |
| FreeMarkerWorker.renderTemplate(location, context, writer); |
| } catch (TemplateException e) { |
| throw new GeneralException(e.getMessage(), e); |
| } |
| |
| return writer.toString(); |
| } |
| |
| public static void renderFile(String dataResourceTypeId, String objectInfo, String rootDir, Appendable out) throws GeneralException, IOException { |
| // TODO: this method assumes the file is a text file, if it is an image we should respond differently, see the comment above for IMAGE_OBJECT type data resource |
| |
| if (dataResourceTypeId.equals("LOCAL_FILE") && UtilValidate.isNotEmpty(objectInfo)) { |
| File file = FileUtil.getFile(objectInfo); |
| if (!file.isAbsolute()) { |
| throw new GeneralException("File (" + objectInfo + ") is not absolute"); |
| } |
| FileReader in = new FileReader(file); |
| UtilIO.copy(in, true, out); |
| } else if (dataResourceTypeId.equals("OFBIZ_FILE") && UtilValidate.isNotEmpty(objectInfo)) { |
| String prefix = System.getProperty("ofbiz.home"); |
| String sep = ""; |
| if (objectInfo.indexOf("/") != 0 && prefix.lastIndexOf("/") != (prefix.length() - 1)) { |
| sep = "/"; |
| } |
| File file = FileUtil.getFile(prefix + sep + objectInfo); |
| FileReader in = new FileReader(file); |
| UtilIO.copy(in, true, out); |
| } else if (dataResourceTypeId.equals("CONTEXT_FILE") && UtilValidate.isNotEmpty(objectInfo)) { |
| String prefix = rootDir; |
| String sep = ""; |
| if (objectInfo.indexOf("/") != 0 && prefix.lastIndexOf("/") != (prefix.length() - 1)) { |
| sep = "/"; |
| } |
| File file = FileUtil.getFile(prefix + sep + objectInfo); |
| FileReader in = null; |
| try { |
| in = new FileReader(file); |
| String enc = in.getEncoding(); |
| if (Debug.infoOn()) Debug.logInfo("in serveImage, encoding:" + enc, module); |
| |
| } catch (FileNotFoundException e) { |
| Debug.logError(e, " in renderDataResourceAsHtml(CONTEXT_FILE), in FNFexception:", module); |
| throw new GeneralException("Could not find context file to render", e); |
| } catch (Exception e) { |
| Debug.logError(" in renderDataResourceAsHtml(CONTEXT_FILE), got exception:" + e.getMessage(), module); |
| } |
| UtilIO.copy(in, true, out); |
| } |
| } |
| |
| // ---------------------------- |
| // Data Resource Streaming |
| // ---------------------------- |
| |
| /** |
| * getDataResourceStream - gets an InputStream and Content-Length of a DataResource |
| * |
| * @param dataResource |
| * @param https |
| * @param webSiteId |
| * @param locale |
| * @param contextRoot |
| * @return Map containing 'stream': the InputStream and 'length' a Long containing the content-length |
| * @throws IOException |
| * @throws GeneralException |
| */ |
| public static Map<String, Object> getDataResourceStream(GenericValue dataResource, String https, String webSiteId, Locale locale, String contextRoot, boolean cache) throws IOException, GeneralException { |
| if (dataResource == null) { |
| throw new GeneralException("Cannot stream null data resource!"); |
| } |
| |
| String dataResourceTypeId = dataResource.getString("dataResourceTypeId"); |
| String dataResourceId = dataResource.getString("dataResourceId"); |
| Delegator delegator = dataResource.getDelegator(); |
| |
| // first text based data |
| if (dataResourceTypeId.endsWith("_TEXT") || "LINK".equals(dataResourceTypeId)) { |
| String text = ""; |
| |
| if ("SHORT_TEXT".equals(dataResourceTypeId) || "LINK".equals(dataResourceTypeId)) { |
| text = dataResource.getString("objectInfo"); |
| } else if ("ELECTRONIC_TEXT".equals(dataResourceTypeId)) { |
| GenericValue electronicText = EntityQuery.use(delegator).from("ElectronicText") |
| .where("dataResourceId", dataResourceId) |
| .cache(cache).queryOne(); |
| if (electronicText != null) { |
| text = electronicText.getString("textData"); |
| } |
| } else { |
| throw new GeneralException("Unsupported TEXT type; cannot stream"); |
| } |
| |
| byte[] bytes = text.getBytes(); |
| return UtilMisc.toMap("stream", new ByteArrayInputStream(bytes), "length", Long.valueOf(bytes.length)); |
| |
| // object (binary) data |
| } else if (dataResourceTypeId.endsWith("_OBJECT")) { |
| byte[] bytes = new byte[0]; |
| GenericValue valObj; |
| |
| if ("IMAGE_OBJECT".equals(dataResourceTypeId)) { |
| valObj = EntityQuery.use(delegator).from("ImageDataResource").where("dataResourceId", dataResourceId).cache(cache).queryOne(); |
| if (valObj != null) { |
| bytes = valObj.getBytes("imageData"); |
| } |
| } else if ("VIDEO_OBJECT".equals(dataResourceTypeId)) { |
| valObj = EntityQuery.use(delegator).from("VideoDataResource").where("dataResourceId", dataResourceId).cache(cache).queryOne(); |
| if (valObj != null) { |
| bytes = valObj.getBytes("videoData"); |
| } |
| } else if ("AUDIO_OBJECT".equals(dataResourceTypeId)) { |
| valObj = EntityQuery.use(delegator).from("AudioDataResource").where("dataResourceId", dataResourceId).cache(cache).queryOne(); |
| if (valObj != null) { |
| bytes = valObj.getBytes("audioData"); |
| } |
| } else if ("OTHER_OBJECT".equals(dataResourceTypeId)) { |
| valObj = EntityQuery.use(delegator).from("OtherDataResource").where("dataResourceId", dataResourceId).cache(cache).queryOne(); |
| if (valObj != null) { |
| bytes = valObj.getBytes("dataResourceContent"); |
| } |
| } else { |
| throw new GeneralException("Unsupported OBJECT type [" + dataResourceTypeId + "]; cannot stream"); |
| } |
| |
| return UtilMisc.toMap("stream", new ByteArrayInputStream(bytes), "length", Long.valueOf(bytes.length)); |
| |
| // file data |
| } else if (dataResourceTypeId.endsWith("_FILE") || dataResourceTypeId.endsWith("_FILE_BIN")) { |
| String objectInfo = dataResource.getString("objectInfo"); |
| if (UtilValidate.isNotEmpty(objectInfo)) { |
| File file = DataResourceWorker.getContentFile(dataResourceTypeId, objectInfo, contextRoot); |
| return UtilMisc.toMap("stream", new ByteArrayInputStream(FileUtils.readFileToByteArray(file)), "length", Long.valueOf(file.length())); |
| } else { |
| throw new GeneralException("No objectInfo found for FILE type [" + dataResourceTypeId + "]; cannot stream"); |
| } |
| |
| // URL resource data |
| } else if ("URL_RESOURCE".equals(dataResourceTypeId)) { |
| String objectInfo = dataResource.getString("objectInfo"); |
| if (UtilValidate.isNotEmpty(objectInfo)) { |
| URL url = new URL(objectInfo); |
| if (url.getHost() == null) { // is relative |
| String newUrl = DataResourceWorker.buildRequestPrefix(delegator, locale, webSiteId, https); |
| if (!newUrl.endsWith("/")) { |
| newUrl = newUrl + "/"; |
| } |
| newUrl = newUrl + url.toString(); |
| url = new URL(newUrl); |
| } |
| |
| URLConnection con = url.openConnection(); |
| return UtilMisc.toMap("stream", con.getInputStream(), "length", Long.valueOf(con.getContentLength())); |
| } else { |
| throw new GeneralException("No objectInfo found for URL_RESOURCE type; cannot stream"); |
| } |
| } |
| |
| // unsupported type |
| throw new GeneralException("The dataResourceTypeId [" + dataResourceTypeId + "] is not supported in getDataResourceStream"); |
| } |
| |
| public static ByteBuffer getContentAsByteBuffer(Delegator delegator, String dataResourceId, String https, String webSiteId, Locale locale, String rootDir) throws IOException, GeneralException { |
| GenericValue dataResource = EntityQuery.use(delegator).from("DataResource").where("dataResourceId", dataResourceId).queryOne(); |
| Map<String, Object> resourceData = DataResourceWorker.getDataResourceStream(dataResource, https, webSiteId, locale, rootDir, false); |
| ByteArrayInputStream stream = (ByteArrayInputStream) resourceData.get("stream"); |
| ByteBuffer byteBuffer = ByteBuffer.wrap(IOUtils.toByteArray(stream)); |
| return byteBuffer; |
| } |
| |
| public String renderDataResourceAsTextExt(Delegator delegator, String dataResourceId, Map<String, Object> templateContext, |
| Locale locale, String targetMimeTypeId, boolean cache) throws GeneralException, IOException { |
| return renderDataResourceAsText(delegator, dataResourceId, templateContext, locale, targetMimeTypeId, cache); |
| } |
| |
| public void renderDataResourceAsTextExt(Delegator delegator, String dataResourceId, Appendable out, Map<String, Object> templateContext, |
| Locale locale, String targetMimeTypeId, boolean cache) throws GeneralException, IOException { |
| renderDataResourceAsText(delegator, dataResourceId, out, templateContext, locale, targetMimeTypeId, cache); |
| } |
| } |
