| /******************************************************************************* |
| * 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.entity.datasource; |
| |
| import java.util.Collection; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.Future; |
| |
| import org.ofbiz.base.util.Debug; |
| import org.ofbiz.entity.GenericEntityException; |
| import org.ofbiz.entity.GenericPK; |
| import org.ofbiz.entity.GenericValue; |
| import org.ofbiz.entity.condition.EntityCondition; |
| import org.ofbiz.entity.model.ModelEntity; |
| import org.ofbiz.entity.model.ModelRelation; |
| import org.ofbiz.entity.util.EntityFindOptions; |
| import org.ofbiz.entity.util.EntityListIterator; |
| |
| /** |
| * Generic Entity Helper Class |
| * |
| */ |
| public class GenericHelperDAO implements GenericHelper { |
| |
| public static final String module = GenericHelperDAO.class.getName(); |
| |
| protected GenericDAO genericDAO; |
| protected GenericHelperInfo helperInfo; |
| |
| public GenericHelperDAO(GenericHelperInfo helperInfo) { |
| this.helperInfo = helperInfo; |
| genericDAO = GenericDAO.getGenericDAO(helperInfo); |
| } |
| |
| public String getHelperName() { |
| return this.helperInfo.getHelperFullName(); |
| } |
| |
| public <T> Future<T> submitWork(Callable<T> callable) throws GenericEntityException { |
| return genericDAO.submitWork(callable); |
| } |
| |
| /** Creates a Entity in the form of a GenericValue and write it to the database |
| *@return GenericValue instance containing the new instance |
| */ |
| public GenericValue create(GenericValue value) throws GenericEntityException { |
| if (value == null) { |
| return null; |
| } |
| int retVal = genericDAO.insert(value); |
| if (Debug.verboseOn()) Debug.logVerbose("Insert Return Value : " + retVal, module); |
| return value; |
| } |
| |
| /** Find a Generic Entity by its Primary Key |
| *@param primaryKey The primary key to find by. |
| *@return The GenericValue corresponding to the primaryKey |
| */ |
| public GenericValue findByPrimaryKey(GenericPK primaryKey) throws GenericEntityException { |
| if (primaryKey == null) { |
| return null; |
| } |
| GenericValue genericValue = GenericValue.create(primaryKey); |
| |
| genericDAO.select(genericValue); |
| return genericValue; |
| } |
| |
| /** Find a Generic Entity by its Primary Key and only returns the values requested by the passed keys (names) |
| *@param primaryKey The primary key to find by. |
| *@param keys The keys, or names, of the values to retrieve; only these values will be retrieved |
| *@return The GenericValue corresponding to the primaryKey |
| */ |
| public GenericValue findByPrimaryKeyPartial(GenericPK primaryKey, Set<String> keys) throws GenericEntityException { |
| if (primaryKey == null) { |
| return null; |
| } |
| GenericValue genericValue = GenericValue.create(primaryKey); |
| |
| genericDAO.partialSelect(genericValue, keys); |
| return genericValue; |
| } |
| |
| /** Find a number of Generic Value objects by their Primary Keys, all at once |
| * This is done here for the DAO GenericHelper; for a client-server helper it |
| * would be done on the server side to reduce network round trips. |
| *@param primaryKeys A List of primary keys to find by. |
| *@return List of GenericValue objects corresponding to the passed primaryKey objects |
| */ |
| public List<GenericValue> findAllByPrimaryKeys(List<GenericPK> primaryKeys) throws GenericEntityException { |
| if (primaryKeys == null) return null; |
| List<GenericValue> results = new LinkedList<GenericValue>(); |
| |
| for (GenericPK primaryKey: primaryKeys) { |
| GenericValue result = this.findByPrimaryKey(primaryKey); |
| |
| if (result != null) results.add(result); |
| } |
| return results; |
| } |
| |
| /** Remove a Generic Entity corresponding to the primaryKey |
| *@param primaryKey The primary key of the entity to remove. |
| *@return int representing number of rows effected by this operation |
| */ |
| public int removeByPrimaryKey(GenericPK primaryKey) throws GenericEntityException { |
| if (primaryKey == null) return 0; |
| if (Debug.verboseOn()) Debug.logVerbose("Removing GenericPK: " + primaryKey.toString(), module); |
| return genericDAO.delete(primaryKey); |
| } |
| |
| /** Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details. |
| *@param modelEntity The ModelEntity of the Entity as defined in the entity XML file |
| *@param whereEntityCondition The EntityCondition object that specifies how to constrain this query before any groupings are done (if this is a view entity with group-by aliases) |
| *@param havingEntityCondition The EntityCondition object that specifies how to constrain this query after any groupings are done (if this is a view entity with group-by aliases) |
| *@param fieldsToSelect The fields of the named entity to get from the database; if empty or null all fields will be retreived |
| *@param orderBy The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending |
| *@param findOptions An instance of EntityFindOptions that specifies advanced query options. See the EntityFindOptions JavaDoc for more details. |
| *@return EntityListIterator representing the result of the query: NOTE THAT THIS MUST BE CLOSED WHEN YOU ARE |
| * DONE WITH IT, AND DON'T LEAVE IT OPEN TOO LONG BEACUSE IT WILL MAINTAIN A DATABASE CONNECTION. |
| */ |
| public EntityListIterator findListIteratorByCondition(ModelEntity modelEntity, EntityCondition whereEntityCondition, |
| EntityCondition havingEntityCondition, Collection<String> fieldsToSelect, List<String> orderBy, EntityFindOptions findOptions) |
| throws GenericEntityException { |
| return genericDAO.selectListIteratorByCondition(modelEntity, whereEntityCondition, havingEntityCondition, fieldsToSelect, orderBy, findOptions); |
| } |
| |
| public List<GenericValue> findByMultiRelation(GenericValue value, ModelRelation modelRelationOne, ModelEntity modelEntityOne, |
| ModelRelation modelRelationTwo, ModelEntity modelEntityTwo, List<String> orderBy) throws GenericEntityException { |
| return genericDAO.selectByMultiRelation(value, modelRelationOne, modelEntityOne, modelRelationTwo, modelEntityTwo, orderBy); |
| } |
| |
| public long findCountByCondition(ModelEntity modelEntity, EntityCondition whereEntityCondition, EntityCondition havingEntityCondition, EntityFindOptions findOptions) throws GenericEntityException { |
| return genericDAO.selectCountByCondition(modelEntity, whereEntityCondition, havingEntityCondition, findOptions); |
| } |
| |
| /** Removes/deletes Generic Entity records found by all the specified condition |
| *@param modelEntity The ModelEntity of the Entity as defined in the entity XML file |
| *@param condition The condition that restricts the list of removed values |
| *@return int representing number of rows effected by this operation |
| */ |
| public int removeByCondition(ModelEntity modelEntity, EntityCondition condition) throws GenericEntityException { |
| if (modelEntity == null || condition == null) { |
| return 0; |
| } |
| return genericDAO.deleteByCondition(modelEntity, condition); |
| } |
| |
| /** Store the Entity from the GenericValue to the persistent store |
| *@param value GenericValue instance containing the entity |
| *@return int representing number of rows effected by this operation |
| */ |
| public int store(GenericValue value) throws GenericEntityException { |
| if (value == null) { |
| return 0; |
| } |
| return genericDAO.update(value); |
| } |
| |
| /** Updates a group of values in a single pass. |
| *@param modelEntity The ModelEntity of the Entity as defined in the entity XML file |
| *@param fieldsToSet The fields of the named entity to set in the database |
| *@param condition The condition that restricts the list of removed values |
| *@return int representing number of rows effected by this operation |
| *@throws GenericEntityException |
| */ |
| public int storeByCondition(ModelEntity modelEntity, Map<String, ? extends Object> fieldsToSet, EntityCondition condition) throws GenericEntityException { |
| if (modelEntity == null || condition == null) { |
| return 0; |
| } |
| return genericDAO.updateByCondition(modelEntity, fieldsToSet, condition); |
| } |
| |
| /** Check the datasource to make sure the entity definitions are correct, optionally adding missing entities or fields on the server |
| *@param modelEntities Map of entityName names and ModelEntity values |
| *@param messages List to put any result messages in |
| *@param addMissing Flag indicating whether or not to add missing entities and fields on the server |
| */ |
| public void checkDataSource(Map<String, ModelEntity> modelEntities, List<String> messages, boolean addMissing) throws GenericEntityException { |
| genericDAO.checkDb(modelEntities, messages, addMissing); |
| } |
| } |