| /******************************************************************************* |
| * 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.ofbiz.widget.screen; |
| |
| import java.io.IOException; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.ListIterator; |
| |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import javolution.util.FastList; |
| import javolution.util.FastMap; |
| |
| import org.ofbiz.base.util.Debug; |
| import org.ofbiz.base.util.GeneralException; |
| import org.ofbiz.base.util.StringUtil; |
| import org.ofbiz.base.util.UtilFormatOut; |
| import org.ofbiz.base.util.UtilGenerics; |
| import org.ofbiz.base.util.UtilMisc; |
| import org.ofbiz.base.util.UtilValidate; |
| import org.ofbiz.base.util.UtilXml; |
| import org.ofbiz.base.util.collections.MapStack; |
| import org.ofbiz.base.util.string.FlexibleStringExpander; |
| import org.ofbiz.entity.Delegator; |
| import org.ofbiz.entity.GenericEntityException; |
| import org.ofbiz.entity.GenericValue; |
| import org.ofbiz.widget.ModelWidget; |
| import org.ofbiz.widget.ModelWidgetAction; |
| import org.ofbiz.widget.WidgetFactory; |
| import org.ofbiz.widget.WidgetWorker; |
| import org.ofbiz.widget.PortalPageWorker; |
| import org.ofbiz.widget.form.FormFactory; |
| import org.ofbiz.widget.form.FormStringRenderer; |
| import org.ofbiz.widget.form.ModelForm; |
| import org.ofbiz.widget.html.HtmlFormRenderer; |
| import org.ofbiz.widget.html.HtmlMenuRenderer; |
| import org.ofbiz.widget.menu.MenuFactory; |
| import org.ofbiz.widget.menu.MenuStringRenderer; |
| import org.ofbiz.widget.menu.ModelMenu; |
| import org.ofbiz.widget.tree.ModelTree; |
| import org.ofbiz.widget.tree.TreeFactory; |
| import org.ofbiz.widget.tree.TreeStringRenderer; |
| import org.w3c.dom.Element; |
| import org.xml.sax.SAXException; |
| import org.ofbiz.entity.condition.*; |
| |
| |
| /** |
| * Widget Library - Screen model class |
| */ |
| @SuppressWarnings("serial") |
| public abstract class ModelScreenWidget extends ModelWidget { |
| public static final String module = ModelScreenWidget.class.getName(); |
| |
| protected ModelScreen modelScreen; |
| |
| public ModelScreenWidget(ModelScreen modelScreen, Element widgetElement) { |
| super(widgetElement); |
| this.modelScreen = modelScreen; |
| if (Debug.verboseOn()) Debug.logVerbose("Reading Screen sub-widget with name: " + widgetElement.getNodeName(), module); |
| } |
| |
| public abstract void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException; |
| |
| public abstract String rawString(); |
| |
| public static List<ModelScreenWidget> readSubWidgets(ModelScreen modelScreen, List<? extends Element> subElementList) { |
| List<ModelScreenWidget> subWidgets = FastList.newInstance(); |
| for (Element subElement: subElementList) { |
| subWidgets.add(WidgetFactory.getModelScreenWidget(modelScreen, subElement)); |
| } |
| return subWidgets; |
| } |
| |
| public static void renderSubWidgetsString(List<ModelScreenWidget> subWidgets, Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| if (subWidgets == null) { |
| return; |
| } |
| for (ModelScreenWidget subWidget: subWidgets) { |
| if (Debug.verboseOn()) Debug.logVerbose("Rendering screen " + subWidget.modelScreen.getName() + "; widget class is " + subWidget.getClass().getName(), module); |
| |
| // render the sub-widget itself |
| subWidget.renderWidgetString(writer, context, screenStringRenderer); |
| } |
| } |
| |
| public ModelScreen getModelScreen() { |
| return this.modelScreen; |
| } |
| |
| public static class SectionsRenderer extends HashMap<String, Object> { |
| protected ScreenStringRenderer screenStringRenderer; |
| protected Map<String, Object> context; |
| protected Appendable writer; |
| |
| public SectionsRenderer(Map<String, ? extends Object> sectionMap, Map<String, Object> context, Appendable writer, ScreenStringRenderer screenStringRenderer) { |
| this.putAll(sectionMap); |
| this.context = context; |
| this.writer = writer; |
| this.screenStringRenderer = screenStringRenderer; |
| } |
| |
| /** This is a lot like the ScreenRenderer class and returns an empty String so it can be used more easily with FreeMarker */ |
| public String render(String sectionName) throws GeneralException, IOException { |
| ModelScreenWidget section = (ModelScreenWidget) this.get(sectionName); |
| // if no section by that name, write nothing |
| if (section != null) { |
| section.renderWidgetString(this.writer, this.context, this.screenStringRenderer); |
| } |
| return ""; |
| } |
| } |
| |
| public static class Section extends ModelScreenWidget { |
| public static final String TAG_NAME = "section"; |
| protected ModelScreenCondition condition; |
| protected List<ModelWidgetAction> actions; |
| protected List<ModelScreenWidget> subWidgets; |
| protected List<ModelScreenWidget> failWidgets; |
| public boolean isMainSection = false; |
| |
| public Section(ModelScreen modelScreen, Element sectionElement) { |
| super(modelScreen, sectionElement); |
| |
| // read condition under the "condition" element |
| Element conditionElement = UtilXml.firstChildElement(sectionElement, "condition"); |
| if (conditionElement != null) { |
| this.condition = new ModelScreenCondition(modelScreen, conditionElement); |
| } |
| |
| // read all actions under the "actions" element |
| Element actionsElement = UtilXml.firstChildElement(sectionElement, "actions"); |
| if (actionsElement != null) { |
| this.actions = ModelWidgetAction.readSubActions(modelScreen, actionsElement); |
| } |
| |
| // read sub-widgets |
| Element widgetsElement = UtilXml.firstChildElement(sectionElement, "widgets"); |
| List<? extends Element> subElementList = UtilXml.childElementList(widgetsElement); |
| this.subWidgets = ModelScreenWidget.readSubWidgets(this.modelScreen, subElementList); |
| |
| // read fail-widgets |
| Element failWidgetsElement = UtilXml.firstChildElement(sectionElement, "fail-widgets"); |
| if (failWidgetsElement != null) { |
| List<? extends Element> failElementList = UtilXml.childElementList(failWidgetsElement); |
| this.failWidgets = ModelScreenWidget.readSubWidgets(this.modelScreen, failElementList); |
| } |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| // check the condition, if there is one |
| boolean condTrue = true; |
| if (this.condition != null) { |
| if (!this.condition.eval(context)) { |
| condTrue = false; |
| } |
| } |
| |
| // if condition does not exist or evals to true run actions and render widgets, otherwise render fail-widgets |
| if (condTrue) { |
| // run the actions only if true |
| ModelWidgetAction.runSubActions(this.actions, context); |
| |
| try { |
| // section by definition do not themselves do anything, so this method will generally do nothing, but we'll call it anyway |
| screenStringRenderer.renderSectionBegin(writer, context, this); |
| |
| // render sub-widgets |
| renderSubWidgetsString(this.subWidgets, writer, context, screenStringRenderer); |
| |
| screenStringRenderer.renderSectionEnd(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering widgets section [" + this.getName() + "] in screen named [" + this.modelScreen.getName() + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } else { |
| try { |
| // section by definition do not themselves do anything, so this method will generally do nothing, but we'll call it anyway |
| screenStringRenderer.renderSectionBegin(writer, context, this); |
| |
| // render sub-widgets |
| renderSubWidgetsString(this.failWidgets, writer, context, screenStringRenderer); |
| |
| screenStringRenderer.renderSectionEnd(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering fail-widgets section [" + this.getName() + "] in screen named [" + this.modelScreen.getName() + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| } |
| |
| @Override |
| public String getBoundaryCommentName() { |
| if (isMainSection) { |
| return modelScreen.getSourceLocation() + "#" + modelScreen.getName(); |
| } else { |
| return name; |
| } |
| } |
| |
| @Override |
| public String rawString() { |
| return "<section" + (UtilValidate.isNotEmpty(this.name)?" name=\"" + this.name + "\"":"") + ">"; |
| } |
| } |
| |
| public static class Container extends ModelScreenWidget { |
| public static final String TAG_NAME = "container"; |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander styleExdr; |
| protected FlexibleStringExpander autoUpdateTargetExdr; |
| protected String autoUpdateInterval = "2"; |
| protected List<ModelScreenWidget> subWidgets; |
| |
| public Container(ModelScreen modelScreen, Element containerElement) { |
| super(modelScreen, containerElement); |
| this.idExdr = FlexibleStringExpander.getInstance(containerElement.getAttribute("id")); |
| this.styleExdr = FlexibleStringExpander.getInstance(containerElement.getAttribute("style")); |
| this.autoUpdateTargetExdr = FlexibleStringExpander.getInstance(containerElement.getAttribute("auto-update-target")); |
| if (containerElement.hasAttribute("auto-update-interval")) { |
| this.autoUpdateInterval = containerElement.getAttribute("auto-update-interval"); |
| } |
| |
| // read sub-widgets |
| List<? extends Element> subElementList = UtilXml.childElementList(containerElement); |
| this.subWidgets = ModelScreenWidget.readSubWidgets(this.modelScreen, subElementList); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| try { |
| screenStringRenderer.renderContainerBegin(writer, context, this); |
| |
| // render sub-widgets |
| renderSubWidgetsString(this.subWidgets, writer, context, screenStringRenderer); |
| |
| screenStringRenderer.renderContainerEnd(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering container in screen named [" + this.modelScreen.getName() + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getStyle(Map<String, Object> context) { |
| return this.styleExdr.expandString(context); |
| } |
| |
| public String getAutoUpdateTargetExdr(Map<String, Object> context) { |
| return this.autoUpdateTargetExdr.expandString(context); |
| } |
| |
| public String getAutoUpdateInterval() { |
| return this.autoUpdateInterval; |
| } |
| |
| @Override |
| public String rawString() { |
| return "<container id=\"" + this.idExdr.getOriginal() + "\" style=\"" + this.styleExdr.getOriginal() + "\" auto-update-target=\"" + this.autoUpdateTargetExdr.getOriginal() + "\">"; |
| } |
| } |
| |
| public static class Screenlet extends ModelScreenWidget { |
| public static final String TAG_NAME = "screenlet"; |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander titleExdr; |
| protected Menu navigationMenu = null; |
| protected Menu tabMenu = null; |
| protected Form navigationForm = null; |
| protected boolean collapsible = false; |
| protected FlexibleStringExpander initiallyCollapsed; |
| protected boolean saveCollapsed = true; |
| protected boolean padded = true; |
| protected List<ModelScreenWidget> subWidgets; |
| |
| public Screenlet(ModelScreen modelScreen, Element screenletElement) { |
| super(modelScreen, screenletElement); |
| this.idExdr = FlexibleStringExpander.getInstance(screenletElement.getAttribute("id")); |
| this.collapsible = "true".equals(screenletElement.getAttribute("collapsible")); |
| this.initiallyCollapsed = FlexibleStringExpander.getInstance(screenletElement.getAttribute("initially-collapsed")); |
| if ("true".equals(this.initiallyCollapsed.getOriginal())) { |
| this.collapsible = true; |
| } |
| // By default, for a collapsible screenlet, the collapsed/expanded status must be saved |
| this.saveCollapsed = !("false".equals(screenletElement.getAttribute("save-collapsed"))); |
| |
| this.padded = !"false".equals(screenletElement.getAttribute("padded")); |
| if (this.collapsible && UtilValidate.isEmpty(this.name) && idExdr.isEmpty()) { |
| throw new IllegalArgumentException("Collapsible screenlets must have a name or id [" + this.modelScreen.getName() + "]"); |
| } |
| this.titleExdr = FlexibleStringExpander.getInstance(screenletElement.getAttribute("title")); |
| List<? extends Element> subElementList = UtilXml.childElementList(screenletElement); |
| this.subWidgets = ModelScreenWidget.readSubWidgets(this.modelScreen, subElementList); |
| String navMenuName = screenletElement.getAttribute("navigation-menu-name"); |
| if (UtilValidate.isNotEmpty(navMenuName)) { |
| for (ModelWidget subWidget : this.subWidgets) { |
| if (navMenuName.equals(subWidget.getName()) && subWidget instanceof Menu) { |
| this.navigationMenu = (Menu) subWidget; |
| subWidgets.remove(subWidget); |
| break; |
| } |
| } |
| } |
| String tabMenuName = screenletElement.getAttribute("tab-menu-name"); |
| if (UtilValidate.isNotEmpty(tabMenuName)) { |
| for (ModelWidget subWidget : this.subWidgets) { |
| if (tabMenuName.equals(subWidget.getName()) && subWidget instanceof Menu) { |
| this.tabMenu = (Menu) subWidget; |
| subWidgets.remove(subWidget); |
| break; |
| } |
| } |
| } |
| String formName = screenletElement.getAttribute("navigation-form-name"); |
| if (UtilValidate.isNotEmpty(formName) && this.navigationMenu == null) { |
| for (ModelWidget subWidget : this.subWidgets) { |
| if (formName.equals(subWidget.getName()) && subWidget instanceof Form) { |
| this.navigationForm = (Form) subWidget; |
| // Let's give this a try, it can be removed later if it |
| // proves to cause problems |
| this.padded = false; |
| break; |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| boolean collapsed = getInitiallyCollapsed(context); |
| if (this.collapsible) { |
| String preferenceKey = getPreferenceKey(context) + "_collapsed"; |
| Map<String, Object> requestParameters = UtilGenerics.checkMap(context.get("requestParameters")); |
| if (requestParameters != null) { |
| String collapsedParam = (String) requestParameters.get(preferenceKey); |
| if (UtilValidate.isNotEmpty(collapsedParam)) { |
| collapsed = "true".equals(collapsedParam); |
| } |
| } |
| } |
| try { |
| screenStringRenderer.renderScreenletBegin(writer, context, collapsed, this); |
| for (ModelScreenWidget subWidget : this.subWidgets) { |
| screenStringRenderer.renderScreenletSubWidget(writer, context, subWidget, this); |
| } |
| screenStringRenderer.renderScreenletEnd(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering screenlet in screen named [" + this.modelScreen.getName() + "]: "; |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg + e); |
| } |
| } |
| |
| public boolean collapsible() { |
| return this.collapsible; |
| } |
| |
| //initially-collapsed status, which may be overriden by user preference |
| public boolean getInitiallyCollapsed(Map<String, Object> context) { |
| String screenletId = this.getId(context) + "_collapsed"; |
| Map<String, ? extends Object> userPreferences = UtilGenerics.checkMap(context.get("userPreferences")); |
| if (userPreferences != null && userPreferences.containsKey(screenletId)) { |
| return Boolean.valueOf((String)userPreferences.get(screenletId)).booleanValue() ; |
| } |
| |
| return "true".equals(this.initiallyCollapsed.expand(context)); |
| } |
| |
| public boolean saveCollapsed() { |
| return this.saveCollapsed; |
| } |
| public boolean padded() { |
| return this.padded; |
| } |
| |
| public String getPreferenceKey(Map<String, Object> context) { |
| String name = this.idExdr.expandString(context); |
| if (UtilValidate.isEmpty(name)) { |
| name = "screenlet" + "_" + Integer.toHexString(hashCode()); |
| } |
| return name; |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getTitle(Map<String, Object> context) { |
| String title = this.titleExdr.expandString(context); |
| StringUtil.SimpleEncoder simpleEncoder = (StringUtil.SimpleEncoder) context.get("simpleEncoder"); |
| if (simpleEncoder != null) { |
| title = simpleEncoder.encode(title); |
| } |
| return title; |
| } |
| |
| public Menu getNavigationMenu() { |
| return this.navigationMenu; |
| } |
| |
| public Form getNavigationForm() { |
| return this.navigationForm; |
| } |
| |
| public Menu getTabMenu() { |
| return this.tabMenu; |
| } |
| |
| @Override |
| public String rawString() { |
| return "<screenlet id=\"" + this.idExdr.getOriginal() + "\" title=\"" + this.titleExdr.getOriginal() + "\">"; |
| } |
| } |
| |
| public static class HorizontalSeparator extends ModelScreenWidget { |
| public static final String TAG_NAME = "horizontal-separator"; |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander styleExdr; |
| |
| public HorizontalSeparator(ModelScreen modelScreen, Element separatorElement) { |
| super(modelScreen, separatorElement); |
| this.idExdr = FlexibleStringExpander.getInstance(separatorElement.getAttribute("id")); |
| this.styleExdr = FlexibleStringExpander.getInstance(separatorElement.getAttribute("style")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| screenStringRenderer.renderHorizontalSeparator(writer, context, this); |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getStyle(Map<String, Object> context) { |
| return this.styleExdr.expandString(context); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<horizontal-separator id=\"" + this.idExdr.getOriginal() + "\" name=\"" + this.idExdr.getOriginal() + "\" style=\"" + this.styleExdr.getOriginal() + "\">"; |
| } |
| } |
| |
| public static class IncludeScreen extends ModelScreenWidget { |
| public static final String TAG_NAME = "include-screen"; |
| protected FlexibleStringExpander nameExdr; |
| protected FlexibleStringExpander locationExdr; |
| protected FlexibleStringExpander shareScopeExdr; |
| |
| public IncludeScreen(ModelScreen modelScreen, Element includeScreenElement) { |
| super(modelScreen, includeScreenElement); |
| this.nameExdr = FlexibleStringExpander.getInstance(includeScreenElement.getAttribute("name")); |
| this.locationExdr = FlexibleStringExpander.getInstance(includeScreenElement.getAttribute("location")); |
| this.shareScopeExdr = FlexibleStringExpander.getInstance(includeScreenElement.getAttribute("share-scope")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| // if we are not sharing the scope, protect it using the MapStack |
| boolean protectScope = !shareScope(context); |
| if (protectScope) { |
| if (!(context instanceof MapStack<?>)) { |
| context = MapStack.create(context); |
| } |
| |
| UtilGenerics.<MapStack<String>>cast(context).push(); |
| |
| // build the widgetpath |
| List<String> widgetTrail = UtilGenerics.toList(context.get("_WIDGETTRAIL_")); |
| if (widgetTrail == null) { |
| widgetTrail = FastList.newInstance(); |
| } |
| |
| String thisName = nameExdr.expandString(context); |
| widgetTrail.add(thisName); |
| context.put("_WIDGETTRAIL_", widgetTrail); |
| } |
| |
| // dont need the renderer here, will just pass this on down to another screen call; screenStringRenderer.renderContainerBegin(writer, context, this); |
| String name = this.getName(context); |
| String location = this.getLocation(context); |
| |
| if (UtilValidate.isEmpty(name)) { |
| if (Debug.verboseOn()) Debug.logVerbose("In the include-screen tag the screen name was empty, ignoring include; in screen [" + this.modelScreen.getName() + "]", module); |
| return; |
| } |
| |
| ScreenFactory.renderReferencedScreen(name, location, this, writer, context, screenStringRenderer); |
| |
| if (protectScope) { |
| UtilGenerics.<MapStack<String>>cast(context).pop(); |
| } |
| } |
| |
| public String getName(Map<String, Object> context) { |
| return this.nameExdr.expandString(context); |
| } |
| |
| public String getLocation(Map<String, Object> context) { |
| return this.locationExdr.expandString(context); |
| } |
| |
| public boolean shareScope(Map<String, Object> context) { |
| String shareScopeString = this.shareScopeExdr.expandString(context); |
| // defaults to false, so anything but true is false |
| return "true".equals(shareScopeString); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<include-screen name=\"" + this.nameExdr.getOriginal() + "\" location=\"" + this.locationExdr.getOriginal() + "\" share-scope=\"" + this.shareScopeExdr.getOriginal() + "\"/>"; |
| } |
| } |
| |
| public static class DecoratorScreen extends ModelScreenWidget { |
| public static final String TAG_NAME = "decorator-screen"; |
| protected FlexibleStringExpander nameExdr; |
| protected FlexibleStringExpander locationExdr; |
| protected Map<String, DecoratorSection> sectionMap = new HashMap<String, DecoratorSection>(); |
| |
| public DecoratorScreen(ModelScreen modelScreen, Element decoratorScreenElement) { |
| super(modelScreen, decoratorScreenElement); |
| this.nameExdr = FlexibleStringExpander.getInstance(decoratorScreenElement.getAttribute("name")); |
| this.locationExdr = FlexibleStringExpander.getInstance(decoratorScreenElement.getAttribute("location")); |
| |
| List<? extends Element> decoratorSectionElementList = UtilXml.childElementList(decoratorScreenElement, "decorator-section"); |
| for (Element decoratorSectionElement: decoratorSectionElementList) { |
| DecoratorSection decoratorSection = new DecoratorSection(modelScreen, decoratorSectionElement); |
| this.sectionMap.put(decoratorSection.getName(), decoratorSection); |
| } |
| } |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| // isolate the scope |
| if (!(context instanceof MapStack)) { |
| context = MapStack.create(context); |
| } |
| |
| MapStack contextMs = (MapStack) context; |
| |
| // create a standAloneStack, basically a "save point" for this SectionsRenderer, and make a new "screens" object just for it so it is isolated and doesn't follow the stack down |
| MapStack standAloneStack = contextMs.standAloneChildStack(); |
| standAloneStack.put("screens", new ScreenRenderer(writer, standAloneStack, screenStringRenderer)); |
| SectionsRenderer sections = new SectionsRenderer(this.sectionMap, standAloneStack, writer, screenStringRenderer); |
| |
| // put the sectionMap in the context, make sure it is in the sub-scope, ie after calling push on the MapStack |
| contextMs.push(); |
| context.put("sections", sections); |
| |
| String name = this.getName(context); |
| String location = this.getLocation(context); |
| |
| ScreenFactory.renderReferencedScreen(name, location, this, writer, context, screenStringRenderer); |
| |
| contextMs.pop(); |
| } |
| |
| public String getName(Map<String, Object> context) { |
| return this.nameExdr.expandString(context); |
| } |
| |
| public String getLocation(Map<String, Object> context) { |
| return this.locationExdr.expandString(context); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<decorator-screen name=\"" + this.nameExdr.getOriginal() + "\" location=\"" + this.locationExdr.getOriginal() + "\"/>"; |
| } |
| } |
| |
| public static class DecoratorSection extends ModelScreenWidget { |
| public static final String TAG_NAME = "decorator-section"; |
| protected List<ModelScreenWidget> subWidgets; |
| |
| public DecoratorSection(ModelScreen modelScreen, Element decoratorSectionElement) { |
| super(modelScreen, decoratorSectionElement); |
| // read sub-widgets |
| List<? extends Element> subElementList = UtilXml.childElementList(decoratorSectionElement); |
| this.subWidgets = ModelScreenWidget.readSubWidgets(this.modelScreen, subElementList); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| // render sub-widgets |
| renderSubWidgetsString(this.subWidgets, writer, context, screenStringRenderer); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<decorator-section name=\"" + this.name + "\">"; |
| } |
| } |
| |
| public static class DecoratorSectionInclude extends ModelScreenWidget { |
| public static final String TAG_NAME = "decorator-section-include"; |
| |
| public DecoratorSectionInclude(ModelScreen modelScreen, Element decoratorSectionElement) { |
| super(modelScreen, decoratorSectionElement); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| Map<String, ? extends Object> preRenderedContent = UtilGenerics.checkMap(context.get("preRenderedContent")); |
| if (preRenderedContent != null && preRenderedContent.containsKey(this.name)) { |
| try { |
| writer.append((String) preRenderedContent.get(this.name)); |
| } catch (IOException e) { |
| String errMsg = "Error rendering pre-rendered content in screen named [" + this.modelScreen.getName() + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } else { |
| SectionsRenderer sections = (SectionsRenderer) context.get("sections"); |
| // for now if sections is null, just log a warning; may be permissible to make the screen for flexible |
| if (sections == null) { |
| Debug.logWarning("In decorator-section-include could not find sections object in the context, not rendering section with name [" + this.name + "]", module); |
| } else { |
| sections.render(this.name); |
| } |
| } |
| } |
| |
| @Override |
| public String rawString() { |
| return "<decorator-section-include name=\"" + this.name + "\">"; |
| } |
| } |
| |
| public static class Label extends ModelScreenWidget { |
| public static final String TAG_NAME = "label"; |
| protected FlexibleStringExpander textExdr; |
| |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander styleExdr; |
| |
| public Label(ModelScreen modelScreen, Element labelElement) { |
| super(modelScreen, labelElement); |
| |
| // put the text attribute first, then the pcdata under the element, if both are there of course |
| String textAttr = UtilFormatOut.checkNull(labelElement.getAttribute("text")); |
| String pcdata = UtilFormatOut.checkNull(UtilXml.elementValue(labelElement)); |
| this.textExdr = FlexibleStringExpander.getInstance(textAttr + pcdata); |
| |
| this.idExdr = FlexibleStringExpander.getInstance(labelElement.getAttribute("id")); |
| this.styleExdr = FlexibleStringExpander.getInstance(labelElement.getAttribute("style")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) { |
| try { |
| screenStringRenderer.renderLabel(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering label in screen named [" + this.modelScreen.getName() + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| public String getText(Map<String, Object> context) { |
| String text = this.textExdr.expandString(context); |
| StringUtil.SimpleEncoder simpleEncoder = (StringUtil.SimpleEncoder) context.get("simpleEncoder"); |
| if (simpleEncoder != null) { |
| text = simpleEncoder.encode(text); |
| } |
| return text; |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getStyle(Map<String, Object> context) { |
| return this.styleExdr.expandString(context); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<label id=\"" + this.idExdr.getOriginal() + "\" style=\"" + this.styleExdr.getOriginal() + "\" text=\"" + this.textExdr.getOriginal() + "\"/>"; |
| } |
| } |
| |
| public static class Form extends ModelScreenWidget { |
| public static final String TAG_NAME = "include-form"; |
| protected FlexibleStringExpander nameExdr; |
| protected FlexibleStringExpander locationExdr; |
| protected FlexibleStringExpander shareScopeExdr; |
| protected ModelForm modelForm = null; |
| |
| public Form(ModelScreen modelScreen, Element formElement) { |
| super(modelScreen, formElement); |
| |
| this.nameExdr = FlexibleStringExpander.getInstance(formElement.getAttribute("name")); |
| this.locationExdr = FlexibleStringExpander.getInstance(formElement.getAttribute("location")); |
| this.shareScopeExdr = FlexibleStringExpander.getInstance(formElement.getAttribute("share-scope")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) { |
| boolean protectScope = !shareScope(context); |
| if (protectScope) { |
| if (!(context instanceof MapStack<?>)) { |
| context = MapStack.create(context); |
| } |
| UtilGenerics.<MapStack<String>>cast(context).push(); |
| } |
| |
| // try finding the formStringRenderer by name in the context in case one was prepared and put there |
| FormStringRenderer formStringRenderer = (FormStringRenderer) context.get("formStringRenderer"); |
| // if there was no formStringRenderer put in place, now try finding the request/response in the context and creating a new one |
| if (formStringRenderer == null) { |
| HttpServletRequest request = (HttpServletRequest) context.get("request"); |
| HttpServletResponse response = (HttpServletResponse) context.get("response"); |
| if (request != null && response != null) { |
| formStringRenderer = new HtmlFormRenderer(request, response); |
| } |
| } |
| // still null, throw an error |
| if (formStringRenderer == null) { |
| throw new IllegalArgumentException("Could not find a formStringRenderer in the context, and could not find HTTP request/response objects need to create one."); |
| } |
| |
| ModelForm modelForm = getModelForm(context); |
| //Debug.logInfo("before renderFormString, context:" + context, module); |
| try { |
| modelForm.renderFormString(writer, context, formStringRenderer); |
| } catch (IOException e) { |
| String errMsg = "Error rendering included form named [" + name + "] at location [" + this.getLocation(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg + e); |
| } |
| |
| if (protectScope) { |
| UtilGenerics.<MapStack<String>>cast(context).pop(); |
| } |
| } |
| |
| public ModelForm getModelForm(Map<String, Object> context) { |
| ModelForm modelForm = null; |
| String name = this.getName(context); |
| String location = this.getLocation(context); |
| try { |
| modelForm = FormFactory.getFormFromLocation(location, name, this.modelScreen.getDelegator(context).getModelReader(), this.modelScreen.getDispatcher(context).getDispatchContext()); |
| } catch (Exception e) { |
| String errMsg = "Error rendering included form named [" + name + "] at location [" + location + "]: "; |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg + e); |
| } |
| return modelForm; |
| } |
| |
| public String getName(Map<String, Object> context) { |
| return this.nameExdr.expandString(context); |
| } |
| |
| public String getLocation(Map<String, Object> context) { |
| return this.locationExdr.expandString(context); |
| } |
| |
| public boolean shareScope(Map<String, Object> context) { |
| String shareScopeString = this.shareScopeExdr.expandString(context); |
| // defaults to false, so anything but true is false |
| return "true".equals(shareScopeString); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<include-form name=\"" + this.nameExdr.getOriginal() + "\" location=\"" + this.locationExdr.getOriginal() + "\" share-scope=\"" + this.shareScopeExdr.getOriginal() + "\"/>"; |
| } |
| } |
| |
| public static class Tree extends ModelScreenWidget { |
| public static final String TAG_NAME = "include-tree"; |
| protected FlexibleStringExpander nameExdr; |
| protected FlexibleStringExpander locationExdr; |
| protected FlexibleStringExpander shareScopeExdr; |
| |
| public Tree(ModelScreen modelScreen, Element treeElement) { |
| super(modelScreen, treeElement); |
| |
| this.nameExdr = FlexibleStringExpander.getInstance(treeElement.getAttribute("name")); |
| this.locationExdr = FlexibleStringExpander.getInstance(treeElement.getAttribute("location")); |
| this.shareScopeExdr = FlexibleStringExpander.getInstance(treeElement.getAttribute("share-scope")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| boolean protectScope = !shareScope(context); |
| if (protectScope) { |
| if (!(context instanceof MapStack<?>)) { |
| context = MapStack.create(context); |
| } |
| UtilGenerics.<MapStack<String>>cast(context).push(); |
| } |
| |
| String name = this.getName(context); |
| String location = this.getLocation(context); |
| ModelTree modelTree = null; |
| try { |
| modelTree = TreeFactory.getTreeFromLocation(this.getLocation(context), this.getName(context), this.modelScreen.getDelegator(context), this.modelScreen.getDispatcher(context)); |
| } catch (IOException e) { |
| String errMsg = "Error rendering included tree named [" + name + "] at location [" + location + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } catch (SAXException e) { |
| String errMsg = "Error rendering included tree named [" + name + "] at location [" + location + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } catch (ParserConfigurationException e) { |
| String errMsg = "Error rendering included tree named [" + name + "] at location [" + location + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| |
| TreeStringRenderer treeStringRenderer = (TreeStringRenderer) context.get("treeStringRenderer"); |
| if (treeStringRenderer == null) { |
| throw new IllegalArgumentException("Could not find a treeStringRenderer in the context"); |
| } |
| |
| StringBuffer renderBuffer = new StringBuffer(); |
| modelTree.renderTreeString(renderBuffer, context, treeStringRenderer); |
| try { |
| writer.append(renderBuffer.toString()); |
| } catch (IOException e) { |
| String errMsg = "Error rendering included tree named [" + name + "] at location [" + location + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| |
| if (protectScope) { |
| UtilGenerics.<MapStack<String>>cast(context).pop(); |
| } |
| } |
| |
| public String getName(Map<String, Object> context) { |
| return this.nameExdr.expandString(context); |
| } |
| |
| public String getLocation(Map<String, Object> context) { |
| return this.locationExdr.expandString(context); |
| } |
| |
| public boolean shareScope(Map<String, Object> context) { |
| String shareScopeString = this.shareScopeExdr.expandString(context); |
| // defaults to false, so anything but true is false |
| return "true".equals(shareScopeString); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<include-tree name=\"" + this.nameExdr.getOriginal() + "\" location=\"" + this.locationExdr.getOriginal() + "\" share-scope=\"" + this.shareScopeExdr.getOriginal() + "\"/>"; |
| } |
| } |
| |
| public static class PlatformSpecific extends ModelScreenWidget { |
| public static final String TAG_NAME = "platform-specific"; |
| protected Map<String, ModelScreenWidget> subWidgets; |
| |
| public PlatformSpecific(ModelScreen modelScreen, Element platformSpecificElement) { |
| super(modelScreen, platformSpecificElement); |
| subWidgets = new HashMap<String, ModelScreenWidget>(); |
| List<? extends Element> childElements = UtilXml.childElementList(platformSpecificElement); |
| if (childElements != null) { |
| for (Element childElement: childElements) { |
| if ("html".equals(childElement.getNodeName())) { |
| subWidgets.put("html", new HtmlWidget(modelScreen, childElement)); |
| } else if ("xsl-fo".equals(childElement.getNodeName())) { |
| subWidgets.put("xsl-fo", new HtmlWidget(modelScreen, childElement)); |
| } else if ("xml".equals(childElement.getNodeName())) { |
| subWidgets.put("xml", new HtmlWidget(modelScreen, childElement)); |
| } else { |
| throw new IllegalArgumentException("Tag not supported under the platform-specific tag with name: " + childElement.getNodeName()); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| ModelScreenWidget subWidget = null; |
| subWidget = subWidgets.get(screenStringRenderer.getRendererName()); |
| if (subWidget == null) { |
| // This is here for backward compatibility |
| Debug.logWarning("In platform-dependent could not find template for " + screenStringRenderer.getRendererName() + ", using the one for html.", module); |
| subWidget = subWidgets.get("html"); |
| } |
| if (subWidget != null) { |
| subWidget.renderWidgetString(writer, context, screenStringRenderer); |
| } |
| } |
| |
| @Override |
| public String rawString() { |
| Collection<ModelScreenWidget> subWidgetList = this.subWidgets.values(); |
| StringBuilder subWidgetsRawString = new StringBuilder("<platform-specific>"); |
| for (ModelScreenWidget subWidget: subWidgetList) { |
| subWidgetsRawString.append(subWidget.rawString()); |
| } |
| return subWidgetsRawString.append("</platform-specific>").toString(); |
| } |
| } |
| |
| public static class Content extends ModelScreenWidget { |
| public static final String TAG_NAME = "content"; |
| |
| protected FlexibleStringExpander contentId; |
| protected FlexibleStringExpander editRequest; |
| protected FlexibleStringExpander editContainerStyle; |
| protected FlexibleStringExpander enableEditName; |
| protected boolean xmlEscape = false; |
| protected FlexibleStringExpander dataResourceId; |
| protected String width; |
| protected String height; |
| protected String border; |
| |
| public Content(ModelScreen modelScreen, Element subContentElement) { |
| super(modelScreen, subContentElement); |
| |
| // put the text attribute first, then the pcdata under the element, if both are there of course |
| this.contentId = FlexibleStringExpander.getInstance(subContentElement.getAttribute("content-id")); |
| this.dataResourceId = FlexibleStringExpander.getInstance(subContentElement.getAttribute("dataresource-id")); |
| this.editRequest = FlexibleStringExpander.getInstance(subContentElement.getAttribute("edit-request")); |
| this.editContainerStyle = FlexibleStringExpander.getInstance(subContentElement.getAttribute("edit-container-style")); |
| this.enableEditName = FlexibleStringExpander.getInstance(subContentElement.getAttribute("enable-edit-name")); |
| this.xmlEscape = "true".equals(subContentElement.getAttribute("xml-escape")); |
| this.width = subContentElement.getAttribute("width"); |
| if (UtilValidate.isEmpty(this.width)) this.width="60%"; |
| this.height = subContentElement.getAttribute("height"); |
| if (UtilValidate.isEmpty(this.height)) this.width="400px"; |
| this.border = subContentElement.getAttribute("border"); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) { |
| try { |
| // pushing the contentId on the context as "contentId" is done |
| // because many times there will be embedded "subcontent" elements |
| // that use the syntax: <subcontent content-id="${contentId}"... |
| // and this is a step to make sure that it is there. |
| Delegator delegator = (Delegator) context.get("delegator"); |
| GenericValue content = null; |
| String expandedDataResourceId = getDataResourceId(context); |
| String expandedContentId = getContentId(context); |
| if (!(context instanceof MapStack<?>)) { |
| context = MapStack.create(context); |
| } |
| |
| // This is an important step to make sure that the current contentId is in the context |
| // as templates that contain "subcontent" elements will expect to find the master |
| // contentId in the context as "contentId". |
| UtilGenerics.<MapStack<String>>cast(context).push(); |
| context.put("contentId", expandedContentId); |
| |
| if (UtilValidate.isEmpty(expandedDataResourceId)) { |
| if (UtilValidate.isNotEmpty(expandedContentId)) { |
| content = delegator.findByPrimaryKeyCache("Content", UtilMisc.toMap("contentId", expandedContentId)); |
| } else { |
| String errMsg = "contentId is empty."; |
| Debug.logError(errMsg, module); |
| return; |
| } |
| if (content != null) { |
| expandedDataResourceId = content.getString("dataResourceId"); |
| } else { |
| String errMsg = "Could not find content with contentId [" + expandedContentId + "] "; |
| Debug.logError(errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| GenericValue dataResource = null; |
| if (UtilValidate.isNotEmpty(expandedDataResourceId)) { |
| dataResource = delegator.findByPrimaryKeyCache("DataResource", UtilMisc.toMap("dataResourceId", expandedDataResourceId)); |
| } |
| |
| String mimeTypeId = null; |
| if (dataResource != null) { |
| mimeTypeId = dataResource.getString("mimeTypeId"); |
| } |
| if (UtilValidate.isNotEmpty(content)) { |
| mimeTypeId = content.getString("mimeTypeId"); |
| } |
| |
| if (UtilValidate.isNotEmpty(mimeTypeId) |
| && ((mimeTypeId.indexOf("application") >= 0) || (mimeTypeId.indexOf("image")) >= 0)) { |
| |
| /* |
| // this code is not yet working, will update it the next few weeks...(Hans) |
| if (mimeTypeId.equals("application/pdf")) { |
| TransformerFactory tfactory = TransformerFactory.newInstance(); |
| try { |
| |
| // |
| // this part is not working. If somebody can help to make it work? |
| // currently using only real temp files for debugging purposes. |
| // |
| // most of the code should be replaced by functions in xslTransform.java and other files. |
| // for debugging here mostly code using the code outside of ofbiz. |
| // |
| SAXParserFactory pfactory= SAXParserFactory.newInstance(); |
| pfactory.setNamespaceAware(true); |
| pfactory.setValidating(true); |
| pfactory.setXIncludeAware(true); |
| XMLReader reader = null; |
| try { |
| reader = pfactory.newSAXParser().getXMLReader(); |
| } catch (Exception e) { |
| throw new TransformerException("Error creating SAX parser/reader", e); |
| } |
| |
| // do the actual preprocessing fr includes |
| String fileName = "/home/hans/ofbiz/svn/applications/commonext/documents/ApacheOfbiz.xml"; |
| SAXSource source = new SAXSource(reader, new InputSource(fileName)); |
| // compile the xsl template |
| Transformer transformer1 = tfactory.newTransformer(new StreamSource("/home/hans/ofbiz/svn/applications/content/template/docbook/fo/docbook.xsl")); |
| // and apply the xsl template to the source document and save in a result string |
| StringWriter sw = new StringWriter(); |
| StreamResult sr = new StreamResult(sw); |
| transformer1.transform(source, sr); |
| // store into a file for debugging |
| // java.io.FileWriter fw = new java.io.FileWriter(new java.io.File("/tmp/file1.fo")); |
| // fw.write(sw.toString()); |
| // fw.close(); |
| |
| |
| FopFactory fopFactory = FopFactory.newInstance(); |
| FOUserAgent foUserAgent = fopFactory.newFOUserAgent(); |
| // configure foUserAgent as desired |
| |
| // Setup output stream. Note: Using BufferedOutputStream |
| // for performance reasons (helpful with FileOutputStreams). |
| // OutputStream out = new FileOutputStream("/tmp/file.pdf"); |
| // out = new BufferedOutputStream(out); |
| // OutputStream outWriter = (OutputStream) writer; |
| ByteArrayOutputStream out = new ByteArrayOutputStream(); |
| Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out); |
| |
| // Setup JAXP using identity transformer |
| TransformerFactory factory = TransformerFactory.newInstance(); |
| Transformer transformer = factory.newTransformer(); // identity transformer |
| |
| // Setup input stream |
| Source src = new StreamSource(new ByteArrayInputStream(sw.toString().getBytes())); |
| |
| // Resulting SAX events (the generated FO) must be piped through to FOP |
| Result result = new SAXResult(fop.getDefaultHandler()); |
| |
| // Start XSLT transformation and FOP processing |
| transformer.transform(src, result); |
| |
| out.flush(); |
| out.close(); |
| // to a file for debugging |
| FileOutputStream fw = new FileOutputStream("/tmp/file.pdf"); |
| fw.write(out.toByteArray()); |
| fw.close(); |
| HttpServletResponse response = (HttpServletResponse) context.get("response"); |
| response.setContentType("application/pdf"); |
| response.setContentLength(out.size()); |
| response.setHeader("Content-Disposition", "attachment;filename=" + fileName); |
| writer.append(new String(out.toByteArray())); |
| } catch(Exception e) { |
| Debug.logError("Exception converting from FO to PDF: " + e, module); |
| } |
| } else { |
| */ screenStringRenderer.renderContentFrame(writer, context, this); |
| // } |
| } else { |
| screenStringRenderer.renderContentBegin(writer, context, this); |
| screenStringRenderer.renderContentBody(writer, context, this); |
| screenStringRenderer.renderContentEnd(writer, context, this); |
| } |
| UtilGenerics.<MapStack<String>>cast(context).pop(); |
| } catch (IOException e) { |
| String errMsg = "Error rendering content with contentId [" + getContentId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } catch (GenericEntityException e) { |
| String errMsg = "Error obtaining content with contentId [" + getContentId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| |
| } |
| |
| public String getContentId(Map<String, Object> context) { |
| return this.contentId.expandString(context); |
| } |
| |
| public String getDataResourceId(Map<String, Object> context) { |
| return this.dataResourceId.expandString(context); |
| } |
| |
| public String getEditRequest(Map<String, Object> context) { |
| return this.editRequest.expandString(context); |
| } |
| |
| public String getEditContainerStyle(Map<String, Object> context) { |
| return this.editContainerStyle.expandString(context); |
| } |
| |
| public String getEnableEditName(Map<String, Object> context) { |
| return this.enableEditName.expandString(context); |
| } |
| |
| public boolean xmlEscape() { |
| return this.xmlEscape; |
| } |
| |
| @Override |
| public String rawString() { |
| // may want to expand this a bit more |
| return "<content content-id=\"" + this.contentId.getOriginal() + "\" xml-escape=\"" + this.xmlEscape + "\"/>"; |
| } |
| |
| public String getWidth() { |
| return this.width; |
| } |
| |
| public String getHeight() { |
| return this.height; |
| } |
| |
| public String getBorder() { |
| return this.border; |
| } |
| } |
| |
| public static class SubContent extends ModelScreenWidget { |
| public static final String TAG_NAME = "sub-content"; |
| protected FlexibleStringExpander contentId; |
| protected FlexibleStringExpander mapKey; |
| protected FlexibleStringExpander editRequest; |
| protected FlexibleStringExpander editContainerStyle; |
| protected FlexibleStringExpander enableEditName; |
| protected boolean xmlEscape = false; |
| |
| public SubContent(ModelScreen modelScreen, Element subContentElement) { |
| super(modelScreen, subContentElement); |
| |
| // put the text attribute first, then the pcdata under the element, if both are there of course |
| this.contentId = FlexibleStringExpander.getInstance(UtilFormatOut.checkNull(subContentElement.getAttribute("content-id"))); |
| this.mapKey = FlexibleStringExpander.getInstance(UtilFormatOut.checkNull(subContentElement.getAttribute("map-key"))); |
| if (this.mapKey.isEmpty()) { |
| this.mapKey = FlexibleStringExpander.getInstance(UtilFormatOut.checkNull(subContentElement.getAttribute("assoc-name"))); |
| } |
| this.editRequest = FlexibleStringExpander.getInstance(UtilFormatOut.checkNull(subContentElement.getAttribute("edit-request"))); |
| this.editContainerStyle = FlexibleStringExpander.getInstance(subContentElement.getAttribute("edit-container-style")); |
| this.enableEditName = FlexibleStringExpander.getInstance(subContentElement.getAttribute("enable-edit-name")); |
| this.xmlEscape = "true".equals(subContentElement.getAttribute("xml-escape")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) { |
| try { |
| screenStringRenderer.renderSubContentBegin(writer, context, this); |
| screenStringRenderer.renderSubContentBody(writer, context, this); |
| screenStringRenderer.renderSubContentEnd(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering subContent with contentId [" + getContentId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| public String getContentId(Map<String, Object> context) { |
| return this.contentId.expandString(context); |
| } |
| |
| public String getMapKey(Map<String, Object> context) { |
| return this.mapKey.expandString(context); |
| } |
| |
| public String getEditRequest(Map<String, Object> context) { |
| return this.editRequest.expandString(context); |
| } |
| |
| public String getEditContainerStyle(Map<String, Object> context) { |
| return this.editContainerStyle.expandString(context); |
| } |
| |
| public String getEnableEditName(Map<String, Object> context) { |
| return this.enableEditName.expandString(context); |
| } |
| |
| public boolean xmlEscape() { |
| return this.xmlEscape; |
| } |
| |
| @Override |
| public String rawString() { |
| // may want to expand this a bit more |
| return "<sub-content content-id=\"" + this.contentId.getOriginal() + "\" map-key=\"" + this.mapKey.getOriginal() + "\" xml-escape=\"" + this.xmlEscape + "\"/>"; |
| } |
| } |
| |
| public static class Menu extends ModelScreenWidget { |
| public static final String TAG_NAME = "include-menu"; |
| protected FlexibleStringExpander nameExdr; |
| protected FlexibleStringExpander locationExdr; |
| |
| public Menu(ModelScreen modelScreen, Element menuElement) { |
| super(modelScreen, menuElement); |
| |
| this.nameExdr = FlexibleStringExpander.getInstance(menuElement.getAttribute("name")); |
| this.locationExdr = FlexibleStringExpander.getInstance(menuElement.getAttribute("location")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws IOException { |
| // try finding the menuStringRenderer by name in the context in case one was prepared and put there |
| MenuStringRenderer menuStringRenderer = (MenuStringRenderer) context.get("menuStringRenderer"); |
| // if there was no menuStringRenderer put in place, now try finding the request/response in the context and creating a new one |
| if (menuStringRenderer == null) { |
| HttpServletRequest request = (HttpServletRequest) context.get("request"); |
| HttpServletResponse response = (HttpServletResponse) context.get("response"); |
| if (request != null && response != null) { |
| menuStringRenderer = new HtmlMenuRenderer(request, response); |
| } |
| } |
| // still null, throw an error |
| if (menuStringRenderer == null) { |
| throw new IllegalArgumentException("Could not find a menuStringRenderer in the context, and could not find HTTP request/response objects need to create one."); |
| } |
| |
| ModelMenu modelMenu = getModelMenu(context); |
| modelMenu.renderMenuString(writer, context, menuStringRenderer); |
| } |
| |
| public ModelMenu getModelMenu(Map<String, Object> context) { |
| String name = this.getName(context); |
| String location = this.getLocation(context); |
| ModelMenu modelMenu = null; |
| try { |
| modelMenu = MenuFactory.getMenuFromLocation(location, name); |
| } catch (Exception e) { |
| String errMsg = "Error rendering included menu named [" + name + "] at location [" + location + "]: "; |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg + e); |
| } |
| return modelMenu; |
| } |
| |
| public String getName(Map<String, Object> context) { |
| return this.nameExdr.expandString(context); |
| } |
| |
| public String getLocation(Map<String, Object> context) { |
| return this.locationExdr.expandString(context); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<include-menu name=\"" + this.nameExdr.getOriginal() + "\" location=\"" + this.locationExdr.getOriginal() + "\"/>"; |
| } |
| } |
| |
| public static class Link extends ModelScreenWidget { |
| public static final String TAG_NAME = "link"; |
| protected FlexibleStringExpander textExdr; |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander styleExdr; |
| protected FlexibleStringExpander targetExdr; |
| protected FlexibleStringExpander targetWindowExdr; |
| protected FlexibleStringExpander prefixExdr; |
| protected FlexibleStringExpander nameExdr; |
| protected Image image; |
| protected String urlMode = "intra-app"; |
| protected boolean fullPath = false; |
| protected boolean secure = false; |
| protected boolean encode = false; |
| protected String linkType; |
| protected String width; |
| protected String height; |
| protected List<WidgetWorker.Parameter> parameterList = FastList.newInstance(); |
| |
| |
| public Link(ModelScreen modelScreen, Element linkElement) { |
| super(modelScreen, linkElement); |
| |
| setText(linkElement.getAttribute("text")); |
| setId(linkElement.getAttribute("id")); |
| setStyle(linkElement.getAttribute("style")); |
| setName(linkElement.getAttribute("name")); |
| setTarget(linkElement.getAttribute("target")); |
| setTargetWindow(linkElement.getAttribute("target-window")); |
| setPrefix(linkElement.getAttribute("prefix")); |
| setUrlMode(linkElement.getAttribute("url-mode")); |
| setFullPath(linkElement.getAttribute("full-path")); |
| setSecure(linkElement.getAttribute("secure")); |
| setEncode(linkElement.getAttribute("encode")); |
| Element imageElement = UtilXml.firstChildElement(linkElement, "image"); |
| if (imageElement != null) { |
| this.image = new Image(modelScreen, imageElement); |
| } |
| |
| this.linkType = linkElement.getAttribute("link-type"); |
| List<? extends Element> parameterElementList = UtilXml.childElementList(linkElement, "parameter"); |
| for (Element parameterElement: parameterElementList) { |
| this.parameterList.add(new WidgetWorker.Parameter(parameterElement)); |
| } |
| |
| this.width = linkElement.getAttribute("width"); |
| this.height = linkElement.getAttribute("height"); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) { |
| try { |
| screenStringRenderer.renderLink(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering link with id [" + getId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| public String getText(Map<String, Object> context) { |
| String text = this.textExdr.expandString(context); |
| StringUtil.SimpleEncoder simpleEncoder = (StringUtil.SimpleEncoder) context.get("simpleEncoder"); |
| if (simpleEncoder != null) { |
| text = simpleEncoder.encode(text); |
| } |
| return text; |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getStyle(Map<String, Object> context) { |
| return this.styleExdr.expandString(context); |
| } |
| |
| public String getTarget(Map<String, Object> context) { |
| Map<String, Object> expanderContext = context; |
| StringUtil.SimpleEncoder simpleEncoder = context == null ? null : (StringUtil.SimpleEncoder) context.get("simpleEncoder"); |
| if (simpleEncoder != null) { |
| expanderContext = StringUtil.HtmlEncodingMapWrapper.getHtmlEncodingMapWrapper(context, simpleEncoder); |
| } |
| return this.targetExdr.expandString(expanderContext); |
| } |
| |
| public String getName(Map<String, Object> context) { |
| return this.nameExdr.expandString(context); |
| } |
| |
| public String getTargetWindow(Map<String, Object> context) { |
| return this.targetWindowExdr.expandString(context); |
| } |
| |
| public String getUrlMode() { |
| return this.urlMode; |
| } |
| |
| public String getPrefix(Map<String, Object> context) { |
| return this.prefixExdr.expandString(context); |
| } |
| |
| public boolean getFullPath() { |
| return this.fullPath; |
| } |
| |
| public boolean getSecure() { |
| return this.secure; |
| } |
| |
| public boolean getEncode() { |
| return this.encode; |
| } |
| |
| public Image getImage() { |
| return this.image; |
| } |
| |
| public String getLinkType() { |
| return this.linkType; |
| } |
| |
| public String getWidth() { |
| return this.width; |
| } |
| |
| public String getHeight() { |
| return this.height; |
| } |
| |
| public Map<String, String> getParameterMap(Map<String, Object> context) { |
| Map<String, String> fullParameterMap = FastMap.newInstance(); |
| |
| /* leaving this here... may want to add it at some point like the hyperlink element: |
| Map<String, String> addlParamMap = this.parametersMapAcsr.get(context); |
| if (addlParamMap != null) { |
| fullParameterMap.putAll(addlParamMap); |
| } |
| */ |
| |
| for (WidgetWorker.Parameter parameter: this.parameterList) { |
| fullParameterMap.put(parameter.getName(), parameter.getValue(context)); |
| } |
| |
| return fullParameterMap; |
| } |
| |
| public void setText(String val) { |
| String textAttr = UtilFormatOut.checkNull(val); |
| this.textExdr = FlexibleStringExpander.getInstance(textAttr); |
| } |
| public void setId(String val) { |
| this.idExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setStyle(String val) { |
| this.styleExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setTarget(String val) { |
| this.targetExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setName(String val) { |
| this.nameExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setTargetWindow(String val) { |
| this.targetWindowExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setPrefix(String val) { |
| this.prefixExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setUrlMode(String val) { |
| if (UtilValidate.isNotEmpty(val)) |
| this.urlMode = val; |
| } |
| public void setFullPath(String val) { |
| String sFullPath = val; |
| if (sFullPath != null && sFullPath.equalsIgnoreCase("true")) |
| this.fullPath = true; |
| else |
| this.fullPath = false; |
| } |
| |
| public void setSecure(String val) { |
| String sSecure = val; |
| if (sSecure != null && sSecure.equalsIgnoreCase("true")) |
| this.secure = true; |
| else |
| this.secure = false; |
| } |
| |
| public void setEncode(String val) { |
| String sEncode = val; |
| if (sEncode != null && sEncode.equalsIgnoreCase("true")) |
| this.encode = true; |
| else |
| this.encode = false; |
| } |
| public void setImage(Image img) { |
| this.image = img; |
| } |
| |
| @Override |
| public String rawString() { |
| // may want to add more to this |
| return "<link id=\"" + this.idExdr.getOriginal() + "\" style=\"" + this.styleExdr.getOriginal() + "\" text=\"" + this.textExdr.getOriginal() + "\" target=\"" + this.targetExdr.getOriginal() + "\" name=\"" + this.nameExdr.getOriginal() + "\" url-mode=\"" + this.urlMode + "\"/>"; |
| } |
| } |
| |
| public static class Image extends ModelScreenWidget { |
| public static final String TAG_NAME = "image"; |
| protected FlexibleStringExpander srcExdr; |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander styleExdr; |
| protected FlexibleStringExpander widthExdr; |
| protected FlexibleStringExpander heightExdr; |
| protected FlexibleStringExpander borderExdr; |
| protected FlexibleStringExpander alt; |
| protected String urlMode = "content"; |
| |
| public Image(ModelScreen modelScreen, Element imageElement) { |
| super(modelScreen, imageElement); |
| |
| setSrc(imageElement.getAttribute("src")); |
| setId(imageElement.getAttribute("id")); |
| setStyle(imageElement.getAttribute("style")); |
| setWidth(imageElement.getAttribute("width")); |
| setHeight(imageElement.getAttribute("height")); |
| setBorder(imageElement.getAttribute("border")); |
| setAlt(imageElement.getAttribute("alt")); |
| setUrlMode(UtilFormatOut.checkEmpty(imageElement.getAttribute("url-mode"), "content")); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) { |
| try { |
| screenStringRenderer.renderImage(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering image with id [" + getId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| public String getSrc(Map<String, Object> context) { |
| return this.srcExdr.expandString(context); |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getStyle(Map<String, Object> context) { |
| return this.styleExdr.expandString(context); |
| } |
| |
| public String getWidth(Map<String, Object> context) { |
| return this.widthExdr.expandString(context); |
| } |
| |
| public String getHeight(Map<String, Object> context) { |
| return this.heightExdr.expandString(context); |
| } |
| |
| public String getBorder(Map<String, Object> context) { |
| return this.borderExdr.expandString(context); |
| } |
| |
| public String getAlt(Map<String, Object> context) { |
| String alt = this.alt.expandString(context); |
| StringUtil.SimpleEncoder simpleEncoder = (StringUtil.SimpleEncoder) context.get("simpleEncoder"); |
| if (simpleEncoder != null) { |
| alt = simpleEncoder.encode(alt); |
| } |
| return alt; |
| } |
| |
| public String getUrlMode() { |
| return this.urlMode; |
| } |
| |
| public void setSrc(String val) { |
| String textAttr = UtilFormatOut.checkNull(val); |
| this.srcExdr = FlexibleStringExpander.getInstance(textAttr); |
| } |
| public void setId(String val) { |
| this.idExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setStyle(String val) { |
| this.styleExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setWidth(String val) { |
| this.widthExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setHeight(String val) { |
| this.heightExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setBorder(String val) { |
| this.borderExdr = FlexibleStringExpander.getInstance(val); |
| } |
| public void setAlt(String val) { |
| String altAttr = UtilFormatOut.checkNull(val); |
| this.alt = FlexibleStringExpander.getInstance(altAttr); |
| } |
| |
| public void setUrlMode(String val) { |
| if (UtilValidate.isEmpty(val)) { |
| this.urlMode = "content"; |
| } else { |
| this.urlMode = val; |
| } |
| } |
| |
| @Override |
| public String rawString() { |
| // may want to add more to this |
| return "<image id=\"" + this.idExdr.getOriginal() + "\" style=\"" + this.styleExdr.getOriginal() + "\" src=\"" + this.srcExdr.getOriginal() + "\" url-mode=\"" + this.urlMode + "\"/>"; |
| } |
| } |
| |
| public static class PortalPage extends ModelScreenWidget { |
| public static final String TAG_NAME = "include-portal-page"; |
| protected FlexibleStringExpander idExdr; |
| protected FlexibleStringExpander confModeExdr; |
| protected String originalPortalPageId; |
| protected String actualPortalPageId; |
| protected Boolean usePrivate; |
| |
| public PortalPage(ModelScreen modelScreen, Element portalPageElement) { |
| super(modelScreen, portalPageElement); |
| this.idExdr = FlexibleStringExpander.getInstance(portalPageElement.getAttribute("id")); |
| this.confModeExdr = FlexibleStringExpander.getInstance(portalPageElement.getAttribute("conf-mode")); |
| this.usePrivate = !("false".equals(portalPageElement.getAttribute("use-private"))); |
| } |
| |
| @Override |
| public void renderWidgetString(Appendable writer, Map<String, Object> context, ScreenStringRenderer screenStringRenderer) throws GeneralException, IOException { |
| try { |
| Delegator delegator = (Delegator) context.get("delegator"); |
| GenericValue portalPage = null; |
| List<GenericValue> portalPageColumns = null; |
| List<GenericValue> portalPagePortlets = null; |
| List<GenericValue> portletAttributes = null; |
| |
| String expandedPortalPageId = getId(context); |
| |
| if (UtilValidate.isNotEmpty(expandedPortalPageId)) { |
| if (usePrivate) { |
| portalPage = PortalPageWorker.getPortalPage(expandedPortalPageId, context); |
| } |
| else { |
| portalPage = delegator.findByPrimaryKeyCache("PortalPage", UtilMisc.toMap("portalPageId", expandedPortalPageId)); |
| } |
| if (portalPage == null) { |
| String errMsg = "Could not find PortalPage with portalPageId [" + expandedPortalPageId + "] "; |
| Debug.logError(errMsg, module); |
| throw new RuntimeException(errMsg); |
| } else { |
| actualPortalPageId = portalPage.getString("portalPageId"); |
| originalPortalPageId = portalPage.getString("originalPortalPageId"); |
| portalPageColumns = delegator.findByAndCache("PortalPageColumn", UtilMisc.toMap("portalPageId", actualPortalPageId), UtilMisc.toList("columnSeqId")); |
| } |
| } else { |
| String errMsg = "portalPageId is empty."; |
| Debug.logError(errMsg, module); |
| return; |
| } |
| |
| // Renders the portalPage header |
| screenStringRenderer.renderPortalPageBegin(writer, context, this); |
| |
| // First column has no previous column |
| String prevColumnSeqId = ""; |
| |
| // Iterates through the PortalPage columns |
| ListIterator <GenericValue>columnsIterator = portalPageColumns.listIterator(); |
| while(columnsIterator.hasNext()) { |
| GenericValue columnValue = columnsIterator.next(); |
| String columnSeqId = columnValue.getString("columnSeqId"); |
| |
| // Renders the portalPageColumn header |
| screenStringRenderer.renderPortalPageColumnBegin(writer, context, this, columnValue); |
| |
| // Get the Portlets located in the current column |
| portalPagePortlets = delegator.findByAnd("PortalPagePortletView", UtilMisc.toMap("portalPageId", portalPage.getString("portalPageId"), "columnSeqId", columnSeqId), UtilMisc.toList("sequenceNum")); |
| |
| // First Portlet in a Column has no previous Portlet |
| String prevPortletId = ""; |
| String prevPortletSeqId = ""; |
| |
| // If this is not the last column, get the next columnSeqId |
| String nextColumnSeqId = ""; |
| if (columnsIterator.hasNext()) { |
| nextColumnSeqId = portalPageColumns.get(columnsIterator.nextIndex()).getString("columnSeqId"); |
| } |
| |
| // Iterates through the Portlets in the Column |
| ListIterator <GenericValue>portletsIterator = portalPagePortlets.listIterator(); |
| while(portletsIterator.hasNext()) { |
| GenericValue portletValue = portletsIterator.next(); |
| |
| // If not the last portlet in the column, get the next nextPortletId and nextPortletSeqId |
| String nextPortletId = ""; |
| String nextPortletSeqId = ""; |
| if (portletsIterator.hasNext()) { |
| nextPortletId = portalPagePortlets.get(portletsIterator.nextIndex()).getString("portalPortletId"); |
| nextPortletSeqId = portalPagePortlets.get(portletsIterator.nextIndex()).getString("portletSeqId"); |
| } |
| |
| // Set info to allow portlet movement in the page |
| context.put("prevPortletId", prevPortletId); |
| context.put("prevPortletSeqId", prevPortletSeqId); |
| context.put("nextPortletId", nextPortletId); |
| context.put("nextPortletSeqId", nextPortletSeqId); |
| context.put("prevColumnSeqId", prevColumnSeqId); |
| context.put("nextColumnSeqId", nextColumnSeqId); |
| |
| // Get portlet's attributes |
| portletAttributes = delegator.findList("PortletAttribute", |
| EntityCondition.makeCondition(UtilMisc.toMap("portalPageId", portletValue.get("portalPageId"), "portalPortletId", portletValue.get("portalPortletId"), "portletSeqId", portletValue.get("portletSeqId"))), |
| null, null, null, false); |
| ListIterator <GenericValue>attributesIterator = portletAttributes.listIterator(); |
| while (attributesIterator.hasNext()) { |
| GenericValue attribute = attributesIterator.next(); |
| context.put(attribute.getString("attrName"), attribute.getString("attrValue")); |
| } |
| |
| // Renders the portalPagePortlet |
| screenStringRenderer.renderPortalPagePortletBegin(writer, context, this, portletValue); |
| screenStringRenderer.renderPortalPagePortletBody(writer, context, this, portletValue); |
| screenStringRenderer.renderPortalPagePortletEnd(writer, context, this, portletValue); |
| |
| // Remove the portlet's attributes so that these are not available for other portlets |
| while (attributesIterator.hasPrevious()) { |
| GenericValue attribute = attributesIterator.previous(); |
| context.remove(attribute.getString("attrName")); |
| } |
| |
| // Uses the actual portlet as prevPortlet for next iteration |
| prevPortletId = (String) portletValue.get("portalPortletId"); |
| prevPortletSeqId = (String) portletValue.get("portletSeqId"); |
| } |
| // Renders the portalPageColumn footer |
| screenStringRenderer.renderPortalPageColumnEnd(writer, context, this, columnValue); |
| |
| // Uses the actual columnSeqId as prevColumnSeqId for next iteration |
| prevColumnSeqId = columnSeqId; |
| } |
| // Renders the portalPage footer |
| screenStringRenderer.renderPortalPageEnd(writer, context, this); |
| } catch (IOException e) { |
| String errMsg = "Error rendering PortalPage with portalPageId [" + getId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } catch (GenericEntityException e) { |
| String errMsg = "Error obtaining PortalPage with portalPageId [" + getId(context) + "]: " + e.toString(); |
| Debug.logError(e, errMsg, module); |
| throw new RuntimeException(errMsg); |
| } |
| } |
| |
| public String getId(Map<String, Object> context) { |
| return this.idExdr.expandString(context); |
| } |
| |
| public String getOriginalPortalPageId() { |
| return this.originalPortalPageId; |
| } |
| |
| public String getActualPortalPageId() { |
| return this.actualPortalPageId; |
| } |
| |
| public String getConfMode(Map<String, Object> context) { |
| return this.confModeExdr.expandString(context); |
| } |
| |
| public String getUsePrivate() { |
| return Boolean.toString(this.usePrivate); |
| } |
| |
| @Override |
| public String rawString() { |
| return "<include-portal-page id=\"" + this.idExdr.getOriginal() + "\" name=\"" + this.idExdr.getOriginal() + "\">"; |
| } |
| } |
| |
| } |
