dataresourceworker.java

Sequoia ERP是一个真正的企业级开源ERP解决方案。它提供的模块包括：电子商务应用(e-commerce), POS系统(point of sales),知识管理,存货与仓库管理

                dataResource.setAllFields(view, true, "dr", null);
            }
            String thisDataResourceId = null;
            try {
                thisDataResourceId = (String) view.get("drDataResourceId");
            } catch (Exception e) {
                thisDataResourceId = (String) view.get("dataResourceId");
            }
            if (UtilValidate.isEmpty(thisDataResourceId)) {
                if (UtilValidate.isNotEmpty(dataResourceId))
                    view = null; // causes lookup of DataResource
                else
                    throw new GeneralException("The dataResourceId [" + dataResourceId + "] is empty.");
            }
        }

        if (dataResource == null || dataResource.isEmpty()) {
            if (dataResourceId == null) {
                throw new GeneralException("DataResourceId is null");
            }
            dataResource = delegator.findByPrimaryKeyCache("DataResource", UtilMisc.toMap("dataResourceId", dataResourceId));
        }
        if (dataResource == null || dataResource.isEmpty()) {
            throw new GeneralException("DataResource not found with id=" + dataResourceId);
        }

        String drMimeTypeId = dataResource.getString("mimeTypeId");
        if (UtilValidate.isEmpty(drMimeTypeId)) {
            drMimeTypeId = "text/plain";
        }

        String dataTemplateTypeId = dataResource.getString("dataTemplateTypeId");
        //if (Debug.infoOn()) Debug.logInfo("in renderDataResourceAsText, dataTemplateTypeId :" + dataTemplateTypeId ,"");

        // if this is a template, we need to get the full template text and interpret it, otherwise we should just write a bit at a time to the writer to better support large text
        if (UtilValidate.isEmpty(dataTemplateTypeId) || "NONE".equals(dataTemplateTypeId)) {
            writeDataResourceTextCache(dataResource, mimeTypeId, locale, templateRoot, delegator, out);
        } else {
            String subContentId = (String)templateRoot.get("subContentId");
            if (UtilValidate.isNotEmpty(subContentId)) {
                templateRoot.put("contentId", subContentId);
                templateRoot.put("subContentId", null);
            }

            templateRoot.put("mimeTypeId", null);

            if ("FTL".equals(dataTemplateTypeId)) {
                try {
                    // This is something of a hack. FTL templates should need "contentId" value and
                    // not subContentId so that it will find subContent.
                    templateRoot.put("contentId", subContentId);
                    templateRoot.put("subContentId", null);
                    templateRoot.put("globalNodeTrail", null); // Force getCurrentContent to query for subContent
                    //if (Debug.infoOn()) Debug.logInfo("in renderDataResourceAsTextCache, templateRoot :" + templateRoot ,"");
                    //StringWriter sw = new StringWriter();
            		// get the full text of the DataResource
                    String templateText = getDataResourceTextCache(dataResource, mimeTypeId, locale, templateRoot, delegator);
                    FreeMarkerWorker.renderTemplate("DataResource:" + dataResourceId, templateText, templateRoot, out);
                    //if (Debug.infoOn()) Debug.logInfo("in renderDataResourceAsText, sw:" + sw.toString(),"");
                    //out.write(sw.toString());
                    //out.flush();
                } catch (TemplateException e) {
                    throw new GeneralException("Error rendering FTL template", e);
                }
            } else if ("SCREEN_COMBINED".equals(dataTemplateTypeId)) {
                try {
                    Map context = MapStack.create(templateRoot);
                    ScreenStringRenderer screenStringRenderer = null;
                    ScreenRenderer screenRenderer = (ScreenRenderer)context.get("screens");
                     if (screenRenderer != null) {
                         screenStringRenderer = screenRenderer.getScreenStringRenderer();
                     } else {
                         if (screenStringRenderer == null) {
                             screenStringRenderer = new HtmlScreenRenderer();
                         }
                     }

                    String combinedName = (String)dataResource.get("objectInfo");
                    ModelScreen modelScreen = ScreenFactory.getScreenFromLocation(combinedName);
                    modelScreen.renderScreenString(out, context, screenStringRenderer);

                } catch (SAXException e) {
                    throw new GeneralException("Error rendering Screen template", e);
                } catch(ParserConfigurationException e3) {
                    throw new GeneralException("Error rendering Screen template", e3);
                }
            } else {
                throw new GeneralException("The dataTemplateTypeId [" + dataTemplateTypeId + "] is not yet supported");
            }
        }
    }

    public static String getDataResourceText(GenericValue dataResource, String mimeTypeId, Locale locale, Map context, GenericDelegator delegator) throws IOException, GeneralException {
        Writer outWriter = new StringWriter();
        writeDataResourceText(dataResource, mimeTypeId, locale, context, delegator, outWriter);
        return outWriter.toString();
    }

    public static void writeDataResourceText(GenericValue dataResource, String mimeTypeId, Locale locale, Map templateContext, GenericDelegator delegator, Writer outWriter) throws IOException, GeneralException {

        Map context = (Map)templateContext.get("context");
        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 dataResourceId = dataResource.getString("dataResourceId");
        String dataResourceTypeId = dataResource.getString("dataResourceTypeId");
        if (UtilValidate.isEmpty(dataResourceTypeId)) {
            dataResourceTypeId = "SHORT_TEXT";
        }

        if (dataResourceTypeId.equals("SHORT_TEXT")) {
            String text = dataResource.getString("objectInfo");
            outWriter.write(text);
        } else if (dataResourceTypeId.equals("ELECTRONIC_TEXT")) {
            GenericValue electronicText = delegator.findByPrimaryKey("ElectronicText", UtilMisc.toMap("dataResourceId", dataResourceId));
            String text = electronicText.getString("textData");
            outWriter.write(text);
        } else if (dataResourceTypeId.equals("IMAGE_OBJECT")) {
            // TODO: Is this where the image (or any binary) object URL is created? looks like it is just returning
            //the ID, maybe is okay, but maybe should create the whole image tag so that text and images can be
            //interchanged without changing the wrapping template, and so the wrapping template doesn't have to know what the root is, etc
            /*
            // decide how to render based on the mime-types
            // TODO: put this in a separate method to be re-used for file objects as well...
            if ("text/html".equals(mimeTypeId)) {
            } else if ("text/plain".equals(mimeTypeId)) {
            } else {
                throw new GeneralException("The renderDataResourceAsText operation does not yet support the desired mime-type: " + mimeTypeId);
            }
            */

            String text = (String) dataResource.get("dataResourceId");
            outWriter.write(text);
        } else if (dataResourceTypeId.equals("LINK")) {
            String text = dataResource.getString("objectInfo");
            outWriter.write(text);
        } else if (dataResourceTypeId.equals("URL_RESOURCE")) {
            String text = null;
            URL url = new URL(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 = buildRequestPrefix(delegator, locale, webSiteId, https);
                String sep = "";
                //String s = "";
                if (url.toString().indexOf("/") != 0 && prefix.lastIndexOf("/") != (prefix.length() - 1)) {
                    sep = "/";
                }
                String s2 = prefix + sep + url.toString();
                URL url2 = new URL(s2);
                text = (String) url2.getContent();
            }
            outWriter.write(text);
        } else if (dataResourceTypeId.indexOf("_FILE") >= 0) {
            String rootDir = (String) templateContext.get("rootDir");
            if (UtilValidate.isEmpty(rootDir)) {
                if (context != null)
                    rootDir = (String) context.get("rootDir");
            }
            if (mimeTypeId != null && mimeTypeId.startsWith("image")) {
            	writeDataResourceText(dataResource, mimeTypeId, locale, context, delegator, outWriter);
            } else {
            	renderFile(dataResourceTypeId, dataResource.getString("objectInfo"), rootDir, outWriter);
            }
        } else {
            throw new GeneralException("The dataResourceTypeId [" + dataResourceTypeId + "] is not supported in renderDataResourceAsText");
        }
    }

    public static String getDataResourceTextCache(GenericValue dataResource, String mimeTypeId, Locale locale, Map context, GenericDelegator delegator) throws IOException, GeneralException {
        Writer outWriter = new StringWriter();
        writeDataResourceText(dataResource, mimeTypeId, locale, context, delegator, outWriter);
        return outWriter.toString();
    }

    public static void writeDataResourceTextCache(GenericValue dataResource, String mimeTypeId, Locale locale, Map context, GenericDelegator delegator, Writer outWriter) throws IOException, GeneralException {

        if (context == null)
            context = new HashMap();

        String text = null;
        String webSiteId = (String) context.get("webSiteId");
        String https = (String) context.get("https");

        String dataResourceId = dataResource.getString("dataResourceId");
        String dataResourceTypeId = dataResource.getString("dataResourceTypeId");
        String dataResourceMimeTypeId = dataResource.getString("mimeTypeId");
        if (UtilValidate.isEmpty(dataResourceTypeId)) {
            dataResourceTypeId = "SHORT_TEXT";
        }

        if (dataResourceTypeId.equals("SHORT_TEXT")) {
            text = dataResource.getString("objectInfo");
            writeText(text, dataResourceMimeTypeId, mimeTypeId, outWriter);
        } else if (dataResourceTypeId.equals("ELECTRONIC_TEXT")) {
            GenericValue electronicText = delegator.findByPrimaryKeyCache("ElectronicText", UtilMisc.toMap("dataResourceId", dataResourceId));
            if (electronicText != null) {
                text = electronicText.getString("textData");
                writeText(text, dataResourceMimeTypeId, mimeTypeId, outWriter);
            }
        } else if (dataResourceTypeId.equals("IMAGE_OBJECT")) {
            // TODO: Is this where the image (or any binary) object URL is created? looks like it is just returning
            //the ID, maybe is okay, but maybe should create the whole image tag so that text and images can be
            //interchanged without changing the wrapping template, and so the wrapping template doesn't have to know what the root is, etc
            /*
            // decide how to render based on the mime-types
            // TODO: put this in a separate method to be re-used for file objects as well...
            if ("text/html".equals(mimeTypeId)) {
            } else if ("text/plain".equals(mimeTypeId)) {
            } else {
                throw new GeneralException("The renderDataResourceAsText operation does not yet support the desired mime-type: " + mimeTypeId);
            }
            */

            text = (String) dataResource.get("dataResourceId");
            writeText(text, dataResourceMimeTypeId, mimeTypeId, outWriter);
        } else if (dataResourceTypeId.equals("LINK")) {
            text = dataResource.getString("objectInfo");
            writeText(text, dataResourceMimeTypeId, mimeTypeId, outWriter);
        } else if (dataResourceTypeId.equals("URL_RESOURCE")) {
            URL url = new URL(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 = buildRequestPrefix(delegator, locale, webSiteId, https);
                String sep = "";
                //String s = "";
                if (url.toString().indexOf("/") != 0 && prefix.lastIndexOf("/") != (prefix.length() - 1)) {
                    sep = "/";
                }
                String s2 = prefix + sep + url.toString();
                URL url2 = new URL(s2);
                text = (String) url2.getContent();
            }
            writeText(text, dataResourceMimeTypeId, mimeTypeId, outWriter);
        } else if (dataResourceTypeId.indexOf("_FILE_BIN") >= 0) {
            String rootDir = (String) context.get("rootDir");
            //renderFileBin(dataResourceTypeId, dataResource.getString("objectInfo"), rootDir, outWriter);
            String objectInfo = dataResource.getString("objectInfo");
            dataResourceMimeTypeId = dataResource.getString("mimeTypeId");
            writeText( dataResourceId, dataResourceMimeTypeId, "text/html", outWriter);
        } else if (dataResourceTypeId.indexOf("_FILE") >= 0) {
            String rootDir = (String) context.get("rootDir");
            dataResourceMimeTypeId = dataResource.getString("mimeTypeId");
            if (dataResourceMimeTypeId == null || dataResourceMimeTypeId.startsWith("text"))
            	renderFile(dataResourceTypeId, dataResource.getString("objectInfo"), rootDir, outWriter);
            else
                writeText( dataResourceId, dataResourceMimeTypeId, "text/html", outWriter);
        } else {
            throw new GeneralException("The dataResourceTypeId [" + dataResourceTypeId + "] is not supported in renderDataResourceAsText");
        }
    }

    public static void writeText( String textData, String dataResourceMimeType, String targetMimeType, Writer out) throws IOException {
        if (UtilValidate.isEmpty(targetMimeType))
            targetMimeType = "text/html";
        if (UtilValidate.isEmpty(dataResourceMimeType))
            dataResourceMimeType = "text/html";

        if (dataResourceMimeType.startsWith("text") ) {
                out.write(textData);
        } else {