| /* |
| * 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.cocoon.forms.binding; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.avalon.framework.logger.Logger; |
| |
| import org.apache.cocoon.forms.datatype.convertor.ConversionResult; |
| import org.apache.cocoon.forms.formmodel.Repeater; |
| import org.apache.cocoon.forms.formmodel.Widget; |
| |
| import org.apache.commons.collections.ListUtils; |
| import org.apache.commons.jxpath.JXPathContext; |
| import org.apache.commons.jxpath.Pointer; |
| |
| /** |
| * RepeaterJXPathBinding provides an implementation of a {@link Binding} |
| * that allows for bidirectional binding of a repeater-widget to/from |
| * repeating structures in the back-end object model. |
| * |
| * @version $Id$ |
| */ |
| public class RepeaterJXPathBinding extends JXPathBindingBase { |
| |
| private final String repeaterId; |
| private final String repeaterPath; |
| private final String rowPath; |
| private final String rowPathForInsert; |
| private final JXPathBindingBase rowBinding; |
| private final JXPathBindingBase insertRowBinding; |
| private final JXPathBindingBase deleteRowBinding; |
| private final ComposedJXPathBindingBase identityBinding; |
| |
| /** |
| * Constructs RepeaterJXPathBinding |
| */ |
| public RepeaterJXPathBinding(JXPathBindingBuilderBase.CommonAttributes commonAtts, |
| String repeaterId, |
| String repeaterPath, |
| String rowPath, |
| String rowPathForInsert, |
| JXPathBindingBase[] childBindings, |
| JXPathBindingBase insertBinding, |
| JXPathBindingBase[] deleteBindings, |
| JXPathBindingBase[] identityBindings) { |
| super(commonAtts); |
| this.repeaterId = repeaterId; |
| this.repeaterPath = repeaterPath; |
| this.rowPath = rowPath; |
| this.rowPathForInsert = rowPathForInsert; |
| |
| this.rowBinding = new ComposedJXPathBindingBase( |
| JXPathBindingBuilderBase.CommonAttributes.DEFAULT, |
| childBindings); |
| this.rowBinding.setParent(this); |
| |
| this.insertRowBinding = insertBinding; |
| if (this.insertRowBinding != null) { |
| this.insertRowBinding.setParent(this); |
| } |
| |
| if (deleteBindings != null) { |
| this.deleteRowBinding = new ComposedJXPathBindingBase( |
| JXPathBindingBuilderBase.CommonAttributes.DEFAULT, |
| deleteBindings); |
| this.deleteRowBinding.setParent(this); |
| } else { |
| this.deleteRowBinding = null; |
| } |
| |
| |
| if (identityBindings != null) { |
| |
| this.identityBinding = new ComposedJXPathBindingBase( |
| JXPathBindingBuilderBase.CommonAttributes.DEFAULT, |
| identityBindings); |
| this.identityBinding.setParent(this); |
| } |
| else |
| this.identityBinding = null; |
| } |
| |
| public void enableLogging(Logger logger) { |
| super.enableLogging(logger); |
| if (this.deleteRowBinding != null) { |
| this.deleteRowBinding.enableLogging(logger); |
| } |
| if (this.insertRowBinding != null) { |
| this.insertRowBinding.enableLogging(logger); |
| } |
| this.rowBinding.enableLogging(logger); |
| if (this.identityBinding != null) { |
| this.identityBinding.enableLogging(logger); |
| } |
| } |
| |
| public String getId() { return repeaterId; } |
| public String getRepeaterPath() { return repeaterPath; } |
| public String getRowPath() { return rowPath; } |
| public String getInsertRowPath() { return rowPathForInsert; } |
| public ComposedJXPathBindingBase getRowBinding() { return (ComposedJXPathBindingBase)rowBinding; } |
| public ComposedJXPathBindingBase getDeleteRowBinding() { return (ComposedJXPathBindingBase)deleteRowBinding; } |
| public ComposedJXPathBindingBase getIdentityBinding() { return identityBinding; } |
| public JXPathBindingBase getInsertRowBinding() { return insertRowBinding; } |
| |
| /** |
| * Binds the unique-id of the repeated rows, and narrows the context on |
| * objectModelContext and Repeater to the repeated rows before handing |
| * over to the actual binding-children. |
| */ |
| public void doLoad(Widget frmModel, JXPathContext jxpc) |
| throws BindingException { |
| // Find the repeater |
| Repeater repeater = (Repeater) selectWidget(frmModel, this.repeaterId); |
| if (repeater == null) { |
| throw new BindingException("The repeater with the ID [" + this.repeaterId |
| + "] referenced in the binding does not exist in the form definition."); |
| } |
| |
| repeater.clear(); |
| |
| Pointer ptr = jxpc.getPointer(this.repeaterPath); |
| if (ptr.getNode() != null) { |
| // There are some nodes to load from |
| final int initialSize = repeater.getSize(); |
| |
| // build a jxpath iterator for pointers |
| JXPathContext repeaterContext = jxpc.getRelativeContext(ptr); |
| Iterator rowPointers = repeaterContext.iteratePointers(this.rowPath); |
| //iterate through it |
| int currentRow = 0; |
| while (rowPointers.hasNext()) { |
| // create a new row, take that as the frmModelSubContext |
| Repeater.RepeaterRow thisRow; |
| if (currentRow < initialSize) { |
| thisRow = repeater.getRow(currentRow++); |
| } else { |
| thisRow = repeater.addRow(); |
| } |
| // make a jxpath ObjectModelSubcontext on the iterated element |
| Pointer jxp = (Pointer)rowPointers.next(); |
| JXPathContext rowContext = repeaterContext.getRelativeContext(jxp); |
| // hand it over to children |
| if (this.identityBinding != null) { |
| this.identityBinding.loadFormFromModel(thisRow, rowContext); |
| } |
| this.rowBinding.loadFormFromModel(thisRow, rowContext); |
| } |
| } |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("done loading rows " + this); |
| } |
| |
| /** |
| * Uses the mapped identity of each row to detect if rows have been |
| * updated, inserted or removed. Depending on what happened the appropriate |
| * child-bindings are allowed to visit the narrowed contexts. |
| */ |
| public void doSave(Widget frmModel, JXPathContext jxpc) |
| throws BindingException { |
| // Find the repeater |
| Repeater repeater = (Repeater) selectWidget(frmModel, this.repeaterId); |
| |
| // and his context, creating the path if needed |
| JXPathContext repeaterContext = |
| jxpc.getRelativeContext(jxpc.createPath(this.repeaterPath)); |
| |
| // create set of updatedRowIds |
| Set updatedRows = new HashSet(); |
| //create list of rows to insert at end |
| List rowsToInsert = new ArrayList(); |
| |
| // iterate rows in the form model... |
| int formRowCount = repeater.getSize(); |
| for (int i = 0; i < formRowCount; i++) { |
| Repeater.RepeaterRow thisRow = repeater.getRow(i); |
| |
| // Get the identity |
| List identity = getIdentity(thisRow); |
| |
| if (hasNonNullElements(identity)) { |
| // iterate nodes to find match |
| Iterator rowPointers = repeaterContext.iteratePointers(this.rowPath); |
| boolean found = false; |
| while (rowPointers.hasNext()) { |
| Pointer jxp = (Pointer) rowPointers.next(); |
| JXPathContext rowContext = repeaterContext.getRelativeContext(jxp); |
| List contextIdentity = getIdentity(rowContext); |
| if (ListUtils.isEqualList(identity, contextIdentity)) { |
| // match! --> bind to children |
| this.rowBinding.saveFormToModel(thisRow, rowContext); |
| // --> store rowIdValue in list of updatedRowIds |
| updatedRows.add(identity); |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| // this is a new row |
| rowsToInsert.add(thisRow); |
| // also add it to the updated row id's so that this row doesn't get deleted |
| updatedRows.add(identity); |
| } |
| } else { |
| // if there is no value to determine the identity --> this is a new row |
| rowsToInsert.add(thisRow); |
| } |
| } |
| // Iterate again nodes for deletion |
| Iterator rowPointers = repeaterContext.iteratePointers(this.rowPath); |
| List rowsToDelete = new ArrayList(); |
| while (rowPointers.hasNext()) { |
| Pointer jxp = (Pointer)rowPointers.next(); |
| JXPathContext rowContext = repeaterContext.getRelativeContext((Pointer)jxp.clone()); |
| List contextIdentity = getIdentity(rowContext); |
| // check if the identity of the rowContext is in the updated rows |
| // if not --> bind for delete |
| if (!isIdentityInUpdatedRows(updatedRows, contextIdentity)) { |
| rowsToDelete.add(rowContext); |
| } |
| } |
| if (rowsToDelete.size() > 0) { |
| // run backwards through the list, so that we don't get into |
| // trouble by shifting indexes |
| for (int i = rowsToDelete.size() - 1; i >= 0; i--) { |
| if (this.deleteRowBinding != null) { |
| this.deleteRowBinding.saveFormToModel(frmModel, |
| rowsToDelete.get(i)); |
| } else { |
| // Simply remove the corresponding path |
| ((JXPathContext)rowsToDelete.get(i)).removePath("."); |
| } |
| } |
| } |
| // count how many we have now |
| int indexCount = 1; |
| rowPointers = repeaterContext.iteratePointers(this.rowPathForInsert); |
| while (rowPointers.hasNext()) { |
| rowPointers.next(); |
| indexCount++; |
| } |
| // end with rows to insert (to make sure they don't get deleted!) |
| if (rowsToInsert.size() > 0) { |
| Iterator rowIterator = rowsToInsert.iterator(); |
| //register the factory! |
| while (rowIterator.hasNext()) { |
| Repeater.RepeaterRow thisRow = (Repeater.RepeaterRow)rowIterator.next(); |
| // Perform the insert row binding. |
| if (this.insertRowBinding != null) { |
| this.insertRowBinding.saveFormToModel(repeater, repeaterContext); |
| } |
| // --> create the path to let the context be created |
| Pointer newRowContextPointer = repeaterContext.createPath( |
| this.rowPathForInsert + "[" + indexCount + "]"); |
| JXPathContext newRowContext = |
| repeaterContext.getRelativeContext(newRowContextPointer); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("inserted row at " + newRowContextPointer.asPath()); |
| } |
| // + rebind to children for update |
| this.rowBinding.saveFormToModel(thisRow, newRowContext); |
| getLogger().debug("bound new row"); |
| indexCount++; |
| } |
| // } else { |
| // if (getLogger().isWarnEnabled()) { |
| // getLogger().warn("RepeaterBinding has detected rows to insert, but misses " |
| // + "the <on-insert-row> binding to do it."); |
| // } |
| // } |
| } |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("done saving rows " + this); |
| } |
| } |
| |
| /** |
| * Tests if an identity is already contained in a Set of identities. |
| * @param identitySet the Set of identities. |
| * @param identity the identity that is tested if it is already in the Set. |
| * @return true if the Set contains the identity, false otherwise. |
| */ |
| private boolean isIdentityInUpdatedRows(Set identitySet, List identity) { |
| Iterator iter = identitySet.iterator(); |
| while (iter.hasNext()) { |
| List identityFromSet = (List)iter.next(); |
| if (ListUtils.isEqualList(identityFromSet, identity)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Tests if any of the elements in a List is not null. |
| * @param list |
| */ |
| protected boolean hasNonNullElements(List list) { |
| Iterator iter = list.iterator(); |
| while (iter.hasNext()) { |
| if (iter.next() != null) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Get the identity of the given row context. That's infact a list of all |
| * the values of the fields in the bean or XML that constitute the identity. |
| * @param rowContext |
| * @return List the identity of the row context |
| */ |
| protected List getIdentity(JXPathContext rowContext) { |
| List identity = Collections.EMPTY_LIST; |
| if (this.identityBinding != null) { |
| JXPathBindingBase[] childBindings = this.identityBinding.getChildBindings(); |
| if (childBindings != null) { |
| int size = childBindings.length; |
| identity = new ArrayList(size); |
| for (int i = 0; i < size; i++) { |
| ValueJXPathBinding vBinding = (ValueJXPathBinding)childBindings[i]; |
| Object value = rowContext.getValue(vBinding.getXPath()); |
| if (value != null && vBinding.getConvertor() != null) { |
| if (value instanceof String) { |
| ConversionResult conversionResult = vBinding.getConvertor().convertFromString( |
| (String)value, vBinding.getConvertorLocale(), null); |
| if (conversionResult.isSuccessful()) { |
| value = conversionResult.getResult(); |
| } else { |
| value = null; |
| } |
| } else { |
| if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Convertor ignored on backend-value " + |
| "which isn't of type String."); |
| } |
| } |
| } |
| identity.add(value); |
| } |
| } |
| } |
| return identity; |
| } |
| |
| /** |
| * Get the identity of the given row. That's in fact a list of all the values |
| * of the fields in the form model that constitute the identity. |
| * @param row |
| * @return List the identity of the row |
| */ |
| protected List getIdentity(Repeater.RepeaterRow row) { |
| // quit if we don't have an identity binding |
| List identity = Collections.EMPTY_LIST; |
| if (this.identityBinding != null) { |
| JXPathBindingBase[] childBindings = this.identityBinding.getChildBindings(); |
| if (childBindings != null) { |
| int size = childBindings.length; |
| identity = new ArrayList(size); |
| for (int i = 0; i < size; i++) { |
| String fieldId = ((ValueJXPathBinding) childBindings[i]).getFieldId(); |
| Widget widget = row.lookupWidget(fieldId); |
| Object value = widget.getValue(); |
| identity.add(value); |
| } |
| } |
| } |
| return identity; |
| } |
| |
| public String toString() { |
| return "RepeaterJXPathBinding [widget=" + this.repeaterId + |
| ", xpath=" + this.repeaterPath + "]"; |
| } |
| } |
