| /******************************************************************************* |
| * 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.shark.expression; |
| |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.enhydra.shark.api.common.ExpressionBuilder; |
| import org.ofbiz.base.util.StringUtil; |
| import org.ofbiz.base.util.UtilMisc; |
| import org.ofbiz.base.util.UtilObject; |
| import org.ofbiz.entity.Delegator; |
| import org.ofbiz.entity.GenericEntityException; |
| import org.ofbiz.entity.util.EntityListIterator; |
| import org.ofbiz.entity.condition.EntityCondition; |
| import org.ofbiz.entity.condition.EntityConditionList; |
| import org.ofbiz.entity.condition.EntityOperator; |
| import org.ofbiz.entity.model.DynamicViewEntity; |
| import org.ofbiz.shark.container.SharkContainer; |
| |
| public abstract class BaseEntityCondExprBldr implements ExpressionBuilder, Serializable { |
| |
| public static final String module = BaseEntityCondExprBldr.class.getName(); |
| |
| protected EntityCondition condition = null; |
| protected Map entityNames = new LinkedHashMap(); |
| protected Map fieldNames = new LinkedHashMap(); |
| protected List autoFields = new ArrayList(); |
| protected List viewLinks = new ArrayList(); |
| |
| protected boolean isOrSet = false; |
| protected boolean isNotSet = false; |
| protected boolean isComplete = true; |
| |
| // ExpressionBuilder Methods |
| |
| public boolean isComplete() { |
| return this.isComplete; |
| } |
| |
| public String toSQL() { |
| return BaseEntityCondExprBldr.getHexString(this); |
| } |
| |
| public String toScript() { |
| return ""; |
| } |
| |
| public String toExpression() { |
| StringBuilder ret = new StringBuilder(); |
| if (!this.isComplete()) { |
| ret.append("/*FORCE*/\n"); |
| } |
| |
| ret.append(this.toScript()); |
| ret.append("\n/*sql ").append(this.toSQL()).append(" sql*/"); |
| |
| return ret.toString(); |
| } |
| |
| // Special Purpose Methods |
| |
| public EntityCondition getCondition() { |
| return this.condition; |
| } |
| |
| public List runQuery() throws GenericEntityException { |
| Delegator delegator = this.getDelegator(); |
| DynamicViewEntity view = this.makeView(); |
| EntityListIterator eli = null; |
| List result = null; |
| try { |
| eli = delegator.findListIteratorByCondition(view, this.getCondition(), null, null, null, null); |
| result = eli.getCompleteList(); |
| } catch (GenericEntityException e) { |
| throw e; |
| } finally { |
| eli.close(); |
| } |
| return result; |
| } |
| |
| protected void setNot(boolean not) { |
| this.isNotSet = not; |
| } |
| |
| protected void setOr(boolean or) { |
| this.isOrSet = or; |
| } |
| |
| protected void addCondition(EntityCondition current) { |
| if (condition == null) { |
| condition = current; |
| } else { |
| List condList = UtilMisc.toList(condition, current); |
| if (this.isOrSet) { |
| condition = EntityCondition.makeCondition(condList, EntityOperator.OR); |
| } else { |
| condition = EntityCondition.makeCondition(condList, EntityOperator.AND); |
| } |
| } |
| // reset the NOT value |
| this.setNot(false); |
| } |
| |
| protected synchronized void addEntity(String alias, String entity) { |
| entityNames.put(alias, entity); |
| } |
| |
| protected synchronized void addField(String entityAlias, String fieldName, String fieldAlias) { |
| Map fieldAliasMap = (Map) fieldNames.get(entityAlias); |
| if (fieldAliasMap == null) { |
| fieldAliasMap = new HashMap(); |
| fieldNames.put(entityAlias, fieldAliasMap); |
| } |
| fieldAliasMap.put(fieldName, fieldAlias); |
| } |
| |
| protected synchronized void addAllFields(String entityAlias) { |
| autoFields.add(entityAlias); |
| } |
| |
| protected synchronized void addLink(String entityAlias, String relEntityAlias, boolean opt, List keyMap) { |
| this.viewLinks.add(new ViewLink(entityAlias, relEntityAlias, opt, keyMap)); |
| } |
| |
| protected Delegator getDelegator() { |
| return SharkContainer.getDelegator(); |
| } |
| |
| private DynamicViewEntity makeView() { |
| DynamicViewEntity view = new DynamicViewEntity(); |
| |
| |
| // create the members |
| Iterator eni = this.entityNames.entrySet().iterator(); |
| while (eni.hasNext()) { |
| Map.Entry entry = (Map.Entry) eni.next(); |
| view.addMemberEntity((String) entry.getKey(), (String) entry.getValue()); |
| } |
| |
| // set alias all fields |
| Iterator aai = autoFields.iterator(); |
| while (aai.hasNext()) { |
| String alias = (String) aai.next(); |
| view.addAliasAll(alias, "", null); |
| } |
| |
| // create the other field aliases |
| Iterator fni = fieldNames.keySet().iterator(); |
| while (fni.hasNext()) { |
| String entityAlias = (String) fni.next(); |
| Map fieldMap = (Map) fieldNames.get(entityAlias); |
| Iterator fmi = fieldMap.entrySet().iterator(); |
| while (fmi.hasNext()) { |
| Map.Entry entry = (Map.Entry) fmi.next(); |
| view.addAlias(entityAlias, (String) entry.getValue(), (String) entry.getKey(), null, null, null, null); |
| } |
| } |
| |
| // add the view links |
| Iterator vli = this.viewLinks.iterator(); |
| while (vli.hasNext()) { |
| ViewLink vl = (ViewLink) vli.next(); |
| view.addViewLink(vl.entityAlias, vl.relEntityAlias, vl.relOptional, vl.keyMaps); |
| } |
| |
| return view; |
| } |
| |
| // Standard Static Serialization Methods |
| |
| public static String getHexString(BaseEntityCondExprBldr builder) { |
| byte[] builderBytes = UtilObject.getBytes(builder); |
| return StringUtil.toHexString(builderBytes); |
| } |
| |
| public static BaseEntityCondExprBldr getBuilder(String hexString) { |
| byte[] builderBytes = StringUtil.fromHexString(hexString); |
| return (BaseEntityCondExprBldr) UtilObject.getObject(builderBytes); |
| } |
| |
| class ViewLink implements Serializable { |
| |
| public String entityAlias; |
| public String relEntityAlias; |
| public boolean relOptional = false; |
| public List keyMaps = new ArrayList(); |
| |
| public ViewLink(String entityAlias, String relEntityAlias, boolean optional, List keyMaps) { |
| this.entityAlias = entityAlias; |
| this.relEntityAlias = relEntityAlias; |
| this.relOptional = optional; |
| this.keyMaps = keyMaps; |
| } |
| } |
| } |