/* * Copyright (C) 2012 Tirasa * * Licensed 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 net.tirasa.hct.editor.beans; import java.io.Serializable; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.TreeMap; import javax.jcr.Node; import javax.jcr.NodeIterator; import javax.jcr.Property; import javax.jcr.PropertyIterator; import javax.jcr.RepositoryException; import javax.jcr.query.Query; import javax.jcr.query.QueryManager; import org.apache.wicket.IClusterable; import org.apache.wicket.Session; import org.hippoecm.frontend.session.UserSession; import org.hippoecm.repository.api.NodeNameCodec; import net.tirasa.hct.editor.Properties; import net.tirasa.hct.editor.forms.components.FilterCond; import net.tirasa.hct.editor.forms.components.OrderCond; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class SummaryBean extends ComponentType implements Comparable<SummaryBean>, IClusterable, Serializable { private static final Logger LOG = LoggerFactory.getLogger(SummaryBean.class); public static final String TYPE = "Summary"; private static final long serialVersionUID = -2987117898057985490L; private transient Node node; private String nodePath; private String path; private String componentName; private String componentType; private String base; private String type; private String depth; private String size; private boolean imageItem; private boolean relatedDocs; private List<FilterBean> filterList; private List<OrderBean> orderList; private List<FieldBean> fieldList; private Map<String, String> properties = new TreeMap<String, String>(); public enum OperationType { AND, OR }; public SummaryBean() { } public SummaryBean(final Node node) throws RepositoryException { this.node = node; this.nodePath = node.getPath().substring(1); this.componentName = NodeNameCodec.decode(node.getName()); filterList = new ArrayList<FilterBean>(); orderList = new ArrayList<OrderBean>(); fieldList = new ArrayList<FieldBean>(); final PropertyIterator pi = node.getProperties(); while (pi.hasNext()) { final Property p = pi.nextProperty(); String name = p.getName(); if (name.startsWith("jcr:")) { //skip continue; } else if (Properties.PROP_COMPTYPE.equals(name)) { componentType = p.getString(); } else if (Properties.PROP_BASE.equals(name)) { base = p.getString(); } else if (Properties.PROP_TYPE.equals(name)) { type = p.getString(); } else if (Properties.PROP_DEPTH.equals(Properties.PROP_DEPTH)) { depth = p.getString(); } else if (Properties.PROP_SIZE.equals(Properties.PROP_SIZE)) { size = p.getString(); } else { properties.put(name, p.getString()); } } final NodeIterator iter = node.getNodes(); while (iter.hasNext()) { final Node childNode = iter.nextNode(); final String nodeName = childNode.getName(); if (Properties.NODE_FILTER.equals(nodeName)) { createFilterList(childNode); } if (Properties.NODE_ORDERBY.equals(nodeName)) { createOrderList(childNode); } if (Properties.NODE_ORDERBY.equals(nodeName)) { createFieldList(childNode); } } } public static QueryManager getQueryManager() throws RepositoryException { return ((UserSession) Session.get()).getQueryManager(); } public static boolean componentExists(final String componentName, final String siteName) { final StringBuilder relPath = new StringBuilder(Properties.HCT_ROOT); relPath.append(Properties.SLASH); relPath.append(siteName); relPath.append(Properties.SLASH); relPath.append(Properties.HCT_COMPONENTS); relPath.append(Properties.SLASH); relPath.append(componentName); try { @SuppressWarnings("deprecation") Query query = getQueryManager().createQuery(relPath.toString(), Query.XPATH); return query.execute().getNodes().hasNext(); } catch (RepositoryException e) { LOG.error("Unable to check if component '{}'" + "exists, returning true", componentName, e); return true; } } /** * Create a new Summary Node * * @throws RepositoryException */ @Override public final void create(final String siteName) throws RepositoryException { if (componentExists(getComponentName(), siteName)) { throw new RepositoryException("Component already exists"); } final StringBuilder relPath = new StringBuilder(Properties.HCT_ROOT); relPath.append(Properties.SLASH); relPath.append(siteName); relPath.append(Properties.SLASH); relPath.append(Properties.HCT_COMPONENTS); relPath.append(Properties.SLASH); relPath.append(getComponentName()); node = ((UserSession) Session.get()).getRootNode(). addNode(relPath.toString()); setOrRemoveStringProperty(node, Properties.PROP_COMPTYPE, TYPE); setOrRemoveStringProperty(node, Properties.PROP_BASE, getBase()); setOrRemoveStringProperty(node, Properties.PROP_DEPTH, getDepth()); setOrRemoveStringProperty(node, Properties.PROP_SIZE, getSize()); setOrRemoveStringProperty(node, Properties.PROP_TYPE, getType()); createNodeFilter(relPath.toString(), node); createNodeOrderBy(relPath.toString(), node); createNodeReturn(relPath.toString(), node); node.getParent().getSession().save(); } private void createNodeFilter(final String relPath, final Node node) throws RepositoryException { Node condFieldNode; Node filterNode = node.addNode(Properties.NODE_FILTER); Node andNode = filterNode.addNode(Properties.NODE_FILTER_AND); Node orNode = filterNode.addNode(Properties.NODE_FILTER_OR); for (Iterator iter = this.getFilterList().iterator(); iter.hasNext();) { FilterBean bean = (FilterBean) iter.next(); StringBuilder nodeName = new StringBuilder("hct:"); nodeName.append(bean.getTypeCond()); if (bean.getOperationType().toString().equals("AND")) { condFieldNode = andNode.addNode(nodeName.toString().toLowerCase()); } else { condFieldNode = orNode.addNode(nodeName.toString().toLowerCase()); } setOrRemoveStringProperty(condFieldNode, Properties.PROP_FIELD, bean.getField()); setOrRemoveStringProperty(condFieldNode, Properties.PROP_VALUE, bean.getField()); } } private void createNodeOrderBy(final String relPath, final Node node) throws RepositoryException { Node orderByNode = node.addNode(Properties.NODE_ORDERBY); for (Iterator iter = this.getOrderList().iterator(); iter.hasNext();) { OrderBean bean = (OrderBean) iter.next(); StringBuilder nodeName = new StringBuilder("hct:"); nodeName.append(bean.getOrderby()); Node orderByFieldNode = orderByNode.addNode(nodeName.toString().toLowerCase()); setOrRemoveStringProperty(orderByFieldNode, Properties.PROP_FIELD, bean.getOrderField()); } } private void createNodeReturn(final String relPath, final Node node) throws RepositoryException { //Create Return Node Node returnNode = node.addNode(Properties.NODE_RETURN); for (Iterator iter = this.getFieldList().iterator(); iter.hasNext();) { FieldBean bean = (FieldBean) iter.next(); Node returnFieldNode = returnNode.addNode(Properties.NODE_RETURN_FIELD); setOrRemoveStringProperty(returnFieldNode, Properties.PROP_NAME, bean.getFieldItem()); } if (getImageItem()) { Node imageFieldNode = returnNode.addNode(Properties.NODE_RETURN_IMAGE); } if (getRelatedDocs()) { Node relatedFieldNode = returnNode.addNode(Properties.NODE_RETURN_RELATEDDOCS); } } /** * * @param node * @param name * @param value * @throws RepositoryException */ private final void setOrRemoveStringProperty( final Node node, final String name, final String value) throws RepositoryException { if (value == null && !node.hasProperty(name)) { return; } node.setProperty(name, value); } /** * save the current component * * @throws RepositoryException */ public final void save(final String siteName) throws RepositoryException { node.remove(); node.getSession().save(); create(siteName); node.getSession().save(); } /** * Delete the current component * * @throws RepositoryException */ @Override public final void delete() throws RepositoryException { Node parent = node.getParent(); node.remove(); parent.getSession().save(); } /** * @see java.lang.Object#equals(java.lang.Object) */ @Override public final boolean equals(final Object obj) { if (obj == this) { return true; } if (obj == null || (obj.getClass() != this.getClass())) { return false; } SummaryBean other = (SummaryBean) obj; return other.getPath().equals(getPath()); } @Override public String getPath() { return path; } @Override public int hashCode() { return (null == path ? 0 : path.hashCode()); } @Override public int compareTo(final SummaryBean o) { String thisName = getComponentName(); String otherName = o.getComponentName(); // int len1 = thisName.length(); int len2 = otherName.length(); int n = Math.min(len1, len2); char v1[] = thisName.toCharArray(); char v2[] = otherName.toCharArray(); int i = 0; int j = 0; if (i == j) { int k = i; int lim = n + i; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; } k++; } } else { while (n-- != 0) { char c1 = v1[i++]; char c2 = v2[j++]; if (c1 != c2) { return c1 - c2; } } } return len1 - len2; } private void createFilterList(final Node childNode) throws RepositoryException { FilterBean filter; NodeIterator iter = childNode.getNodes(); while (iter.hasNext()) { final Node andOrNode = iter.nextNode(); NodeIterator i = andOrNode.getNodes(); while (i.hasNext()) { filter = new FilterBean(); final Node item = i.nextNode(); if (andOrNode.getName().substring(4).equals( OperationType.AND.toString())) { filter.setOperationType(FilterBean.OperationType.AND); } else { filter.setOperationType(FilterBean.OperationType.OR); } filter.setTypeCond(FilterCond.Type.valueOf( item.getName().substring(4).toUpperCase())); PropertyIterator pi = item.getProperties(); while (pi.hasNext()) { final Property p = pi.nextProperty(); String name = p.getName(); if (name.startsWith("jcr:")) { //skip continue; } else if (Properties.PROP_FIELD.equals(name)) { filter.setField(p.getString()); } else if (Properties.PROP_VALUE.equals(name)) { filter.setFilterValue(p.getString()); } } filterList.add(filter); } } } private void createOrderList(final Node childNode) throws RepositoryException { OrderBean order; final NodeIterator iterator = childNode.getNodes(); while (iterator.hasNext()) { order = new OrderBean(); final Node n = iterator.nextNode(); order.setOrderby(OrderCond.Type.valueOf(n.getName().substring(4). toUpperCase().toUpperCase())); final PropertyIterator pi = n.getProperties(); while (pi.hasNext()) { final Property p = pi.nextProperty(); String name = p.getName(); if (name.startsWith("jcr:")) { //skip continue; } else if (Properties.PROP_FIELD.equals(name)) { order.setOrderField(p.getString()); } } orderList.add(order); } } private void createFieldList(final Node childNode) throws RepositoryException { FieldBean field; final NodeIterator iterator = childNode.getNodes(); while (iterator.hasNext()) { final Node n = iterator.nextNode(); if (Properties.NODE_RETURN_FIELD.equals(n.getName())) { field = new FieldBean(); field.setFieldItem(n.getProperty(Properties.PROP_NAME). getString()); fieldList.add(field); } } if (childNode.hasNode(Properties.NODE_RETURN_IMAGE)) { this.imageItem = true; } if (childNode.hasNode(Properties.NODE_RETURN_RELATEDDOCS)) { this.relatedDocs = true; } } @Override public final String getComponentName() { return componentName; } public final void setComponentName(final String componentName) { this.componentName = componentName; } public final String getBase() { return base; } public final void setBase(final String base) { this.base = base; } public final String getDepth() { return depth; } public final void setDepth(final String depth) { this.depth = depth; } public final String getSize() { return size; } public final void setSize(final String size) { this.size = size; } public final String getType() { return type; } public final void setType(final String type) { this.type = type; } public final boolean getImageItem() { return imageItem; } public final void setImageItem(final boolean imageItem) { this.imageItem = imageItem; } public final boolean getRelatedDocs() { return relatedDocs; } public final void setRelatedDocs(final boolean relatedDocs) { this.relatedDocs = relatedDocs; } public final List<FilterBean> getFilterList() { return filterList; } public final void setFilterList(final List filterList) { this.filterList = filterList; } public final List<OrderBean> getOrderList() { return orderList; } public final void setOrderList(final List orderList) { this.orderList = orderList; } @Override public final List<FieldBean> getFieldList() { return fieldList; } public final void setFieldList(final List fieldList) { this.fieldList = fieldList; } public final String getComponentType() { return componentType; } public final void setComponentType(String componentType) { this.componentType = componentType; } @Override public final String getNodePath() { return this.nodePath; } @Override public final String getDisplayName() { return componentName; } }