// --------------------------------------------------------------------------------
// Copyright 2002-2026 Echo Three, LLC
//
// 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.
// --------------------------------------------------------------------------------
// Generated File -- DO NOT EDIT BY HAND
// --------------------------------------------------------------------------------

/**
 * CustomerFactory.java
 */

package com.echothree.model.data.customer.server.factory;

import com.echothree.model.data.party.common.pk.PartyPK;
import com.echothree.model.data.customer.common.pk.CustomerTypePK;
import com.echothree.model.data.offer.common.pk.OfferUsePK;
import com.echothree.model.data.cancellationpolicy.common.pk.CancellationPolicyPK;
import com.echothree.model.data.returnpolicy.common.pk.ReturnPolicyPK;
import com.echothree.model.data.accounting.common.pk.GlAccountPK;

import com.echothree.model.data.party.server.entity.Party;
import com.echothree.model.data.customer.server.entity.CustomerType;
import com.echothree.model.data.offer.server.entity.OfferUse;
import com.echothree.model.data.cancellationpolicy.server.entity.CancellationPolicy;
import com.echothree.model.data.returnpolicy.server.entity.ReturnPolicy;
import com.echothree.model.data.accounting.server.entity.GlAccount;

import com.echothree.model.data.customer.common.CustomerConstants;
import com.echothree.model.data.customer.common.pk.CustomerPK;
import com.echothree.model.data.customer.server.value.CustomerValue;
import com.echothree.model.data.customer.server.entity.Customer;
import com.echothree.util.common.exception.PersistenceDatabaseException;
import com.echothree.util.common.exception.PersistenceDatabaseUpdateException;
import com.echothree.util.common.exception.PersistenceNotNullException;
import com.echothree.util.server.persistence.BaseFactory;
import com.echothree.util.server.persistence.EntityIdGenerator;
import com.echothree.util.server.persistence.EntityPermission;
import com.echothree.util.server.persistence.PersistenceDebugFlags;
import com.echothree.util.server.persistence.Session;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.io.ByteArrayInputStream;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.spi.CDI;
import javax.inject.Inject;
import org.jooq.ResultQuery;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@ApplicationScoped
public class CustomerFactory
        implements BaseFactory<CustomerPK, Customer> {
    
    @Inject
    Session session;
    
    //private static final Logger log = LoggerFactory.getLogger(CustomerFactory.class);
    
    final private static String SQL_SELECT_READ_ONLY = "SELECT cu_customerid, cu_par_partyid, cu_customername, cu_cuty_customertypeid, cu_initialofferuseid, cu_cnclplcy_cancellationpolicyid, cu_rtnplcy_returnpolicyid, cu_arglaccountid, cu_holduntilcomplete, cu_allowbackorders, cu_allowsubstitutions, cu_allowcombiningshipments, cu_requirereference, cu_allowreferenceduplicates, cu_referencevalidationpattern, cu_fromtime, cu_thrutime FROM customers WHERE cu_customerid = ?";
    final private static String SQL_SELECT_READ_WRITE = "SELECT cu_customerid, cu_par_partyid, cu_customername, cu_cuty_customertypeid, cu_initialofferuseid, cu_cnclplcy_cancellationpolicyid, cu_rtnplcy_returnpolicyid, cu_arglaccountid, cu_holduntilcomplete, cu_allowbackorders, cu_allowsubstitutions, cu_allowcombiningshipments, cu_requirereference, cu_allowreferenceduplicates, cu_referencevalidationpattern, cu_fromtime, cu_thrutime FROM customers WHERE cu_customerid = ? FOR UPDATE";
    final private static String SQL_INSERT = "INSERT INTO customers (cu_customerid, cu_par_partyid, cu_customername, cu_cuty_customertypeid, cu_initialofferuseid, cu_cnclplcy_cancellationpolicyid, cu_rtnplcy_returnpolicyid, cu_arglaccountid, cu_holduntilcomplete, cu_allowbackorders, cu_allowsubstitutions, cu_allowcombiningshipments, cu_requirereference, cu_allowreferenceduplicates, cu_referencevalidationpattern, cu_fromtime, cu_thrutime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    final private static String SQL_UPDATE = "UPDATE customers SET cu_par_partyid = ?, cu_customername = ?, cu_cuty_customertypeid = ?, cu_initialofferuseid = ?, cu_cnclplcy_cancellationpolicyid = ?, cu_rtnplcy_returnpolicyid = ?, cu_arglaccountid = ?, cu_holduntilcomplete = ?, cu_allowbackorders = ?, cu_allowsubstitutions = ?, cu_allowcombiningshipments = ?, cu_requirereference = ?, cu_allowreferenceduplicates = ?, cu_referencevalidationpattern = ?, cu_fromtime = ?, cu_thrutime = ? WHERE cu_customerid = ?";
    final private static String SQL_DELETE = "DELETE FROM customers WHERE cu_customerid = ?";
    final private static String SQL_VALID = "SELECT COUNT(*) FROM customers WHERE cu_customerid = ?";
    
    final public static String CU_CUSTOMERID = "cu_customerid";
    final public static String CU_PAR_PARTYID = "cu_par_partyid";
    final public static String CU_CUSTOMERNAME = "cu_customername";
    final public static String CU_CUTY_CUSTOMERTYPEID = "cu_cuty_customertypeid";
    final public static String CU_INITIALOFFERUSEID = "cu_initialofferuseid";
    final public static String CU_CNCLPLCY_CANCELLATIONPOLICYID = "cu_cnclplcy_cancellationpolicyid";
    final public static String CU_RTNPLCY_RETURNPOLICYID = "cu_rtnplcy_returnpolicyid";
    final public static String CU_ARGLACCOUNTID = "cu_arglaccountid";
    final public static String CU_HOLDUNTILCOMPLETE = "cu_holduntilcomplete";
    final public static String CU_ALLOWBACKORDERS = "cu_allowbackorders";
    final public static String CU_ALLOWSUBSTITUTIONS = "cu_allowsubstitutions";
    final public static String CU_ALLOWCOMBININGSHIPMENTS = "cu_allowcombiningshipments";
    final public static String CU_REQUIREREFERENCE = "cu_requirereference";
    final public static String CU_ALLOWREFERENCEDUPLICATES = "cu_allowreferenceduplicates";
    final public static String CU_REFERENCEVALIDATIONPATTERN = "cu_referencevalidationpattern";
    final public static String CU_FROMTIME = "cu_fromtime";
    final public static String CU_THRUTIME = "cu_thrutime";
    
    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(CustomerConstants.COMPONENT_VENDOR_NAME, CustomerConstants.ENTITY_TYPE_NAME);
    
    /** Creates a new instance of CustomerFactory */
    protected CustomerFactory() {
        super();
    }
    
    public static CustomerFactory getInstance() {
        return CDI.current().select(CustomerFactory.class).get();
    }
    
    @Override
    public String getComponentVendorName() {
        return CustomerConstants.COMPONENT_VENDOR_NAME;
    }
    
    @Override
    public String getEntityTypeName() {
        return CustomerConstants.ENTITY_TYPE_NAME;
    }
    
    public PreparedStatement prepareStatement(String query) {
        return session.prepareStatement(query);
    }
    
    public CustomerPK getNextPK() {
        return new CustomerPK(entityIdGenerator.getNextEntityId());
    }
    
    public Set<CustomerPK> getPKsFromResultSetAsSet(ResultSet rs)
            throws PersistenceDatabaseException {
        Set<CustomerPK> _result = new HashSet<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<CustomerPK> getPKsFromResultSetAsList(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<CustomerPK> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public CustomerPK getPKFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        CustomerPK _result;
        
        try {
            long cu_customerid = rs.getLong(CU_CUSTOMERID);
            Long _entityId = rs.wasNull() ? null : cu_customerid;
            
            _result = new CustomerPK(_entityId);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<CustomerValue> getValuesFromPKs(Collection<CustomerPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<CustomerValue> _values = new ArrayList<>(pks.size());
        
        for(CustomerPK _pk: pks) {
            _values.add(getValueFromPK(_pk));
        }
        
        return _values;
    }
    
    public CustomerValue getValueFromPK(CustomerPK pk)
            throws PersistenceDatabaseException {
        CustomerValue _value;
        
        // See if we already have the entity in the session cache
        Customer _entity = (Customer)session.getEntity(pk);
        if(_entity == null)
            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getCustomerValue();
        else
            _value = _entity.getCustomerValue();
        
        return _value;
    }
    
    public java.util.List<CustomerValue> getValuesFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<CustomerValue> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getValueFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public CustomerValue getValueFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        CustomerValue _value;
        
        try {
            Long cu_customerid = rs.getLong(CU_CUSTOMERID);
            CustomerPK _pk = new CustomerPK(cu_customerid);
            
            // See if we already have the entity in the session cache
            Customer _entity = (Customer)session.getEntity(_pk);
            
            if(_entity == null) {
                Long cu_par_partyid = rs.getLong(CU_PAR_PARTYID);
                if(rs.wasNull())
                    cu_par_partyid = null;
                
                String cu_customername = rs.getString(CU_CUSTOMERNAME);
                if(rs.wasNull())
                    cu_customername = null;
                
                Long cu_cuty_customertypeid = rs.getLong(CU_CUTY_CUSTOMERTYPEID);
                if(rs.wasNull())
                    cu_cuty_customertypeid = null;
                
                Long cu_initialofferuseid = rs.getLong(CU_INITIALOFFERUSEID);
                if(rs.wasNull())
                    cu_initialofferuseid = null;
                
                Long cu_cnclplcy_cancellationpolicyid = rs.getLong(CU_CNCLPLCY_CANCELLATIONPOLICYID);
                if(rs.wasNull())
                    cu_cnclplcy_cancellationpolicyid = null;
                
                Long cu_rtnplcy_returnpolicyid = rs.getLong(CU_RTNPLCY_RETURNPOLICYID);
                if(rs.wasNull())
                    cu_rtnplcy_returnpolicyid = null;
                
                Long cu_arglaccountid = rs.getLong(CU_ARGLACCOUNTID);
                if(rs.wasNull())
                    cu_arglaccountid = null;
                
                Boolean cu_holduntilcomplete = rs.getInt(CU_HOLDUNTILCOMPLETE) == 1;
                if(rs.wasNull())
                    cu_holduntilcomplete = null;
                
                Boolean cu_allowbackorders = rs.getInt(CU_ALLOWBACKORDERS) == 1;
                if(rs.wasNull())
                    cu_allowbackorders = null;
                
                Boolean cu_allowsubstitutions = rs.getInt(CU_ALLOWSUBSTITUTIONS) == 1;
                if(rs.wasNull())
                    cu_allowsubstitutions = null;
                
                Boolean cu_allowcombiningshipments = rs.getInt(CU_ALLOWCOMBININGSHIPMENTS) == 1;
                if(rs.wasNull())
                    cu_allowcombiningshipments = null;
                
                Boolean cu_requirereference = rs.getInt(CU_REQUIREREFERENCE) == 1;
                if(rs.wasNull())
                    cu_requirereference = null;
                
                Boolean cu_allowreferenceduplicates = rs.getInt(CU_ALLOWREFERENCEDUPLICATES) == 1;
                if(rs.wasNull())
                    cu_allowreferenceduplicates = null;
                
                String cu_referencevalidationpattern = rs.getString(CU_REFERENCEVALIDATIONPATTERN);
                if(rs.wasNull())
                    cu_referencevalidationpattern = null;
                
                Long cu_fromtime = rs.getLong(CU_FROMTIME);
                if(rs.wasNull())
                    cu_fromtime = null;
                
                Long cu_thrutime = rs.getLong(CU_THRUTIME);
                if(rs.wasNull())
                    cu_thrutime = null;
                
                _value = new CustomerValue(_pk, new PartyPK(cu_par_partyid), cu_customername, new CustomerTypePK(cu_cuty_customertypeid), new OfferUsePK(cu_initialofferuseid), new CancellationPolicyPK(cu_cnclplcy_cancellationpolicyid), new ReturnPolicyPK(cu_rtnplcy_returnpolicyid), new GlAccountPK(cu_arglaccountid), cu_holduntilcomplete, cu_allowbackorders, cu_allowsubstitutions, cu_allowcombiningshipments, cu_requirereference, cu_allowreferenceduplicates, cu_referencevalidationpattern, cu_fromtime, cu_thrutime);
            } else
                _value = _entity.getCustomerValue();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _value;
    }
    
    public java.util.List<Customer> getEntitiesFromPKs(EntityPermission entityPermission, Collection<CustomerPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<Customer> _entities = new ArrayList<>(pks.size());
        
        for(CustomerPK _pk: pks) {
            _entities.add(getEntityFromPK(entityPermission, _pk));
        }
        
        return _entities;
    }
    
    public Customer getEntityFromValue(EntityPermission entityPermission, CustomerValue value) {
        return getEntityFromPK(entityPermission, value.getPrimaryKey());
    }
    
    public Customer getEntityFromCache(CustomerPK pk) {
        CustomerValue _value = (CustomerValue)session.getValueCache().get(pk);
    
        return _value == null ? null : new Customer(_value, EntityPermission.READ_ONLY);
    }
    
    public Customer getEntityFromPK(EntityPermission entityPermission, CustomerPK pk)
            throws PersistenceDatabaseException {
        Customer _entity;
        
        // See if we already have the entity in the session cache
        _entity = (Customer)session.getEntity(pk);
        if(_entity != null) {
            // If the requested permission is READ_WRITE, and the cached permission is
            // READ_ONLY, then pretend that the cached object wasn't found, and create
            // a new entity that is READ_WRITE.
            if(entityPermission.equals(EntityPermission.READ_WRITE)) {
                if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
                    _entity = null;
            }
        }
        
        if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
            _entity = getEntityFromCache(pk);
        }
        
        if(_entity == null) {
            PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE);
            long _entityId = pk.getEntityId();
            ResultSet _rs = null;
            
            try {
                _ps.setLong(1, _entityId);
                _rs = _ps.executeQuery();
                if(_rs.next()) {
                    _entity = getEntityFromResultSet(entityPermission, _rs);
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            } finally {
                if(_rs != null) {
                    try {
                        _rs.close();
                    } catch (SQLException se) {
                        // do nothing
                    }
                }
            }
        }
        
        return _entity;
    }
    
    public Set<CustomerPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        Set<CustomerPK> _pks;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _pks = getPKsFromResultSetAsSet(_rs);
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _pks;
    }
    
    public java.util.List<CustomerPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<CustomerPK> _pks;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _pks = getPKsFromResultSetAsList(_rs);
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _pks;
    }
    
    public CustomerPK getPKFromQuery(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        CustomerPK _pk = null;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            if(_rs.next()) {
                _pk = getPKFromResultSet(_rs);
            }
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _pk;
    }
    
    public java.util.List<Customer> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(entityPermission, ps, params);
    }
    
    public java.util.List<Customer> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(entityPermission, ps);
    }
    
    public java.util.List<Customer> getEntitiesFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(query.getSQL());
        
        return getEntitiesFromQuery(entityPermission, ps, query.getBindValues().toArray());
    }
    
    public java.util.List<Customer> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<Customer> _entities;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _entities = getEntitiesFromResultSet(entityPermission, _rs);
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _entities;
    }
    
    public Customer getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
        
        return getEntityFromQuery(entityPermission, ps, params);
    }
    
    public Customer getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
        
        return getEntityFromQuery(entityPermission, ps);
    }
    
    public Customer getEntityFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(query.getSQL());
        
        return getEntityFromQuery(entityPermission, ps, query.getBindValues().toArray());
    }
    
    public Customer getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        Customer _entity = null;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            if(_rs.next()) {
                _entity = getEntityFromResultSet(entityPermission, _rs);
            }
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _entity;
    }
    
    public java.util.List<Customer> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<Customer> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getEntityFromResultSet(entityPermission, rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public Customer getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        Customer _entity;
        
        try {
            Long cu_customerid = rs.getLong(CU_CUSTOMERID);
            CustomerPK _pk = new CustomerPK(cu_customerid);
            
            // See if we already have the entity in the session cache
            _entity = (Customer)session.getEntity(_pk);
            if(_entity != null) {
                // If the requested permission is READ_WRITE, and the cached permission is
                // READ_ONLY, then pretend that the cached object wasn't found, and create
                // a new entity that is READ_WRITE.
                if(entityPermission.equals(EntityPermission.READ_WRITE)) {
                    if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
                        _entity = null;
                }
            }
            boolean foundInSessionCache = _entity != null;
            
            if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
                _entity = getEntityFromCache(_pk);
            }
            
            if(_entity == null) {
                Long cu_par_partyid = rs.getLong(CU_PAR_PARTYID);
                if(rs.wasNull())
                    cu_par_partyid = null;
                
                String cu_customername = rs.getString(CU_CUSTOMERNAME);
                if(rs.wasNull())
                    cu_customername = null;
                
                Long cu_cuty_customertypeid = rs.getLong(CU_CUTY_CUSTOMERTYPEID);
                if(rs.wasNull())
                    cu_cuty_customertypeid = null;
                
                Long cu_initialofferuseid = rs.getLong(CU_INITIALOFFERUSEID);
                if(rs.wasNull())
                    cu_initialofferuseid = null;
                
                Long cu_cnclplcy_cancellationpolicyid = rs.getLong(CU_CNCLPLCY_CANCELLATIONPOLICYID);
                if(rs.wasNull())
                    cu_cnclplcy_cancellationpolicyid = null;
                
                Long cu_rtnplcy_returnpolicyid = rs.getLong(CU_RTNPLCY_RETURNPOLICYID);
                if(rs.wasNull())
                    cu_rtnplcy_returnpolicyid = null;
                
                Long cu_arglaccountid = rs.getLong(CU_ARGLACCOUNTID);
                if(rs.wasNull())
                    cu_arglaccountid = null;
                
                Boolean cu_holduntilcomplete = rs.getInt(CU_HOLDUNTILCOMPLETE) == 1;
                if(rs.wasNull())
                    cu_holduntilcomplete = null;
                
                Boolean cu_allowbackorders = rs.getInt(CU_ALLOWBACKORDERS) == 1;
                if(rs.wasNull())
                    cu_allowbackorders = null;
                
                Boolean cu_allowsubstitutions = rs.getInt(CU_ALLOWSUBSTITUTIONS) == 1;
                if(rs.wasNull())
                    cu_allowsubstitutions = null;
                
                Boolean cu_allowcombiningshipments = rs.getInt(CU_ALLOWCOMBININGSHIPMENTS) == 1;
                if(rs.wasNull())
                    cu_allowcombiningshipments = null;
                
                Boolean cu_requirereference = rs.getInt(CU_REQUIREREFERENCE) == 1;
                if(rs.wasNull())
                    cu_requirereference = null;
                
                Boolean cu_allowreferenceduplicates = rs.getInt(CU_ALLOWREFERENCEDUPLICATES) == 1;
                if(rs.wasNull())
                    cu_allowreferenceduplicates = null;
                
                String cu_referencevalidationpattern = rs.getString(CU_REFERENCEVALIDATIONPATTERN);
                if(rs.wasNull())
                    cu_referencevalidationpattern = null;
                
                Long cu_fromtime = rs.getLong(CU_FROMTIME);
                if(rs.wasNull())
                    cu_fromtime = null;
                
                Long cu_thrutime = rs.getLong(CU_THRUTIME);
                if(rs.wasNull())
                    cu_thrutime = null;
                
                CustomerValue _value = new CustomerValue(_pk, cu_par_partyid == null? null: new PartyPK(cu_par_partyid), cu_customername, cu_cuty_customertypeid == null? null: new CustomerTypePK(cu_cuty_customertypeid), cu_initialofferuseid == null? null: new OfferUsePK(cu_initialofferuseid), cu_cnclplcy_cancellationpolicyid == null? null: new CancellationPolicyPK(cu_cnclplcy_cancellationpolicyid), cu_rtnplcy_returnpolicyid == null? null: new ReturnPolicyPK(cu_rtnplcy_returnpolicyid), cu_arglaccountid == null? null: new GlAccountPK(cu_arglaccountid), cu_holduntilcomplete, cu_allowbackorders, cu_allowsubstitutions, cu_allowcombiningshipments, cu_requirereference, cu_allowreferenceduplicates, cu_referencevalidationpattern, cu_fromtime, cu_thrutime);
                _entity = new Customer(_value, entityPermission);
            }
            
            if(!foundInSessionCache) {
                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
                    session.putReadOnlyEntity(_pk, _entity);
                    session.getValueCache().put(_entity.getCustomerValue());
                } else {
                    session.putReadWriteEntity(_pk, _entity);
                }
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _entity;
    }
    
    public Customer create(Party party, String customerName, CustomerType customerType, OfferUse initialOfferUse, CancellationPolicy cancellationPolicy, ReturnPolicy returnPolicy, GlAccount arGlAccount, Boolean holdUntilComplete, Boolean allowBackorders, Boolean allowSubstitutions, Boolean allowCombiningShipments, Boolean requireReference, Boolean allowReferenceDuplicates, String referenceValidationPattern, Long fromTime, Long thruTime)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        return create(party == null ? null : party.getPrimaryKey(), customerName, customerType == null ? null : customerType.getPrimaryKey(), initialOfferUse == null ? null : initialOfferUse.getPrimaryKey(), cancellationPolicy == null ? null : cancellationPolicy.getPrimaryKey(), returnPolicy == null ? null : returnPolicy.getPrimaryKey(), arGlAccount == null ? null : arGlAccount.getPrimaryKey(), holdUntilComplete, allowBackorders, allowSubstitutions, allowCombiningShipments, requireReference, allowReferenceDuplicates, referenceValidationPattern, fromTime, thruTime);
    }
    
    private void bindForCreate(PreparedStatement _ps, CustomerValue _value)
            throws SQLException {
        _ps.setLong(1, _value.getEntityId());
        
        PartyPK cu_par_partyid = _value.getPartyPK();
        if(cu_par_partyid == null)
            _ps.setNull(2, Types.BIGINT);
        else
            _ps.setLong(2, cu_par_partyid.getEntityId());
            
        String cu_customername = _value.getCustomerName();
        if(cu_customername == null)
            _ps.setNull(3, Types.VARCHAR);
        else
            _ps.setString(3, cu_customername);
            
        CustomerTypePK cu_cuty_customertypeid = _value.getCustomerTypePK();
        if(cu_cuty_customertypeid == null)
            _ps.setNull(4, Types.BIGINT);
        else
            _ps.setLong(4, cu_cuty_customertypeid.getEntityId());
            
        OfferUsePK cu_initialofferuseid = _value.getInitialOfferUsePK();
        if(cu_initialofferuseid == null)
            _ps.setNull(5, Types.BIGINT);
        else
            _ps.setLong(5, cu_initialofferuseid.getEntityId());
            
        CancellationPolicyPK cu_cnclplcy_cancellationpolicyid = _value.getCancellationPolicyPK();
        if(cu_cnclplcy_cancellationpolicyid == null)
            _ps.setNull(6, Types.BIGINT);
        else
            _ps.setLong(6, cu_cnclplcy_cancellationpolicyid.getEntityId());
            
        ReturnPolicyPK cu_rtnplcy_returnpolicyid = _value.getReturnPolicyPK();
        if(cu_rtnplcy_returnpolicyid == null)
            _ps.setNull(7, Types.BIGINT);
        else
            _ps.setLong(7, cu_rtnplcy_returnpolicyid.getEntityId());
            
        GlAccountPK cu_arglaccountid = _value.getArGlAccountPK();
        if(cu_arglaccountid == null)
            _ps.setNull(8, Types.BIGINT);
        else
            _ps.setLong(8, cu_arglaccountid.getEntityId());
            
        Boolean cu_holduntilcomplete = _value.getHoldUntilComplete();
        if(cu_holduntilcomplete == null)
            _ps.setNull(9, Types.BIT);
        else
            _ps.setInt(9, cu_holduntilcomplete? 1: 0);
            
        Boolean cu_allowbackorders = _value.getAllowBackorders();
        if(cu_allowbackorders == null)
            _ps.setNull(10, Types.BIT);
        else
            _ps.setInt(10, cu_allowbackorders? 1: 0);
            
        Boolean cu_allowsubstitutions = _value.getAllowSubstitutions();
        if(cu_allowsubstitutions == null)
            _ps.setNull(11, Types.BIT);
        else
            _ps.setInt(11, cu_allowsubstitutions? 1: 0);
            
        Boolean cu_allowcombiningshipments = _value.getAllowCombiningShipments();
        if(cu_allowcombiningshipments == null)
            _ps.setNull(12, Types.BIT);
        else
            _ps.setInt(12, cu_allowcombiningshipments? 1: 0);
            
        Boolean cu_requirereference = _value.getRequireReference();
        if(cu_requirereference == null)
            _ps.setNull(13, Types.BIT);
        else
            _ps.setInt(13, cu_requirereference? 1: 0);
            
        Boolean cu_allowreferenceduplicates = _value.getAllowReferenceDuplicates();
        if(cu_allowreferenceduplicates == null)
            _ps.setNull(14, Types.BIT);
        else
            _ps.setInt(14, cu_allowreferenceduplicates? 1: 0);
            
        String cu_referencevalidationpattern = _value.getReferenceValidationPattern();
        if(cu_referencevalidationpattern == null)
            _ps.setNull(15, Types.VARCHAR);
        else
            _ps.setString(15, cu_referencevalidationpattern);
            
        Long cu_fromtime = _value.getFromTime();
        if(cu_fromtime == null)
            _ps.setNull(16, Types.BIGINT);
        else
            _ps.setLong(16, cu_fromtime);
            
        Long cu_thrutime = _value.getThruTime();
        if(cu_thrutime == null)
            _ps.setNull(17, Types.BIGINT);
        else
            _ps.setLong(17, cu_thrutime);
            
    }
    
    public Customer create(PartyPK partyPK, String customerName, CustomerTypePK customerTypePK, OfferUsePK initialOfferUsePK, CancellationPolicyPK cancellationPolicyPK, ReturnPolicyPK returnPolicyPK, GlAccountPK arGlAccountPK, Boolean holdUntilComplete, Boolean allowBackorders, Boolean allowSubstitutions, Boolean allowCombiningShipments, Boolean requireReference, Boolean allowReferenceDuplicates, String referenceValidationPattern, Long fromTime, Long thruTime)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        CustomerPK _pk = getNextPK();
        CustomerValue _value = new CustomerValue(_pk, partyPK, customerName, customerTypePK, initialOfferUsePK, cancellationPolicyPK, returnPolicyPK, arGlAccountPK, holdUntilComplete, allowBackorders, allowSubstitutions, allowCombiningShipments, requireReference, allowReferenceDuplicates, referenceValidationPattern, fromTime, thruTime);
        
        PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
        
        try {
            bindForCreate(_ps, _value);
            
            if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
                int _count = _ps.executeUpdate();
                
                if(_count != 1) {
                    throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count);
                }
            } else {
                 _ps.executeUpdate();
            }
            
            session.getValueCache().put(_value);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        Customer _entity = new Customer(_value, EntityPermission.READ_ONLY);
        session.putReadOnlyEntity(_pk, _entity);
        
        return _entity;
    }
    
    public void create(Collection<CustomerValue> _values)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        int _size = _values.size();
        
        if(_size > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
            List<CustomerValue> _cacheValues = new ArrayList<>(_size);
            
            try {
                for(CustomerValue _value : _values) {
                    _value.setEntityId(entityIdGenerator.getNextEntityId());
                    bindForCreate(_ps, _value);
                    
                    _ps.addBatch();
                    
                    _cacheValues.add(_value);
                }
                
                if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
                    int[] _counts = _ps.executeBatch();
                    
                    for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) {
                        if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
                            throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
                        }
                    }
                } else {
                     _ps.executeBatch();
                }
                
                _ps.clearBatch();
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
            
            _cacheValues.forEach((_cacheValue) -> {
                Customer _cacheEntity = new Customer(_cacheValue, EntityPermission.READ_ONLY);
                
                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
            });
        }
    }
    
    private boolean bindForStore(PreparedStatement _ps, CustomerValue _value)
            throws SQLException {
        boolean _hasBeenModified = _value.hasBeenModified();
        
        if(_hasBeenModified) {
            PartyPK cu_par_partyid = _value.getPartyPK();
            if(cu_par_partyid == null)
                _ps.setNull(1, Types.BIGINT);
            else
                _ps.setLong(1, cu_par_partyid.getEntityId());
            
            String cu_customername = _value.getCustomerName();
            if(cu_customername == null)
                _ps.setNull(2, Types.VARCHAR);
            else
                _ps.setString(2, cu_customername);
            
            CustomerTypePK cu_cuty_customertypeid = _value.getCustomerTypePK();
            if(cu_cuty_customertypeid == null)
                _ps.setNull(3, Types.BIGINT);
            else
                _ps.setLong(3, cu_cuty_customertypeid.getEntityId());
            
            OfferUsePK cu_initialofferuseid = _value.getInitialOfferUsePK();
            if(cu_initialofferuseid == null)
                _ps.setNull(4, Types.BIGINT);
            else
                _ps.setLong(4, cu_initialofferuseid.getEntityId());
            
            CancellationPolicyPK cu_cnclplcy_cancellationpolicyid = _value.getCancellationPolicyPK();
            if(cu_cnclplcy_cancellationpolicyid == null)
                _ps.setNull(5, Types.BIGINT);
            else
                _ps.setLong(5, cu_cnclplcy_cancellationpolicyid.getEntityId());
            
            ReturnPolicyPK cu_rtnplcy_returnpolicyid = _value.getReturnPolicyPK();
            if(cu_rtnplcy_returnpolicyid == null)
                _ps.setNull(6, Types.BIGINT);
            else
                _ps.setLong(6, cu_rtnplcy_returnpolicyid.getEntityId());
            
            GlAccountPK cu_arglaccountid = _value.getArGlAccountPK();
            if(cu_arglaccountid == null)
                _ps.setNull(7, Types.BIGINT);
            else
                _ps.setLong(7, cu_arglaccountid.getEntityId());
            
            Boolean cu_holduntilcomplete = _value.getHoldUntilComplete();
            if(cu_holduntilcomplete == null)
                _ps.setNull(8, Types.BIT);
            else
                _ps.setInt(8, cu_holduntilcomplete? 1: 0);
            
            Boolean cu_allowbackorders = _value.getAllowBackorders();
            if(cu_allowbackorders == null)
                _ps.setNull(9, Types.BIT);
            else
                _ps.setInt(9, cu_allowbackorders? 1: 0);
            
            Boolean cu_allowsubstitutions = _value.getAllowSubstitutions();
            if(cu_allowsubstitutions == null)
                _ps.setNull(10, Types.BIT);
            else
                _ps.setInt(10, cu_allowsubstitutions? 1: 0);
            
            Boolean cu_allowcombiningshipments = _value.getAllowCombiningShipments();
            if(cu_allowcombiningshipments == null)
                _ps.setNull(11, Types.BIT);
            else
                _ps.setInt(11, cu_allowcombiningshipments? 1: 0);
            
            Boolean cu_requirereference = _value.getRequireReference();
            if(cu_requirereference == null)
                _ps.setNull(12, Types.BIT);
            else
                _ps.setInt(12, cu_requirereference? 1: 0);
            
            Boolean cu_allowreferenceduplicates = _value.getAllowReferenceDuplicates();
            if(cu_allowreferenceduplicates == null)
                _ps.setNull(13, Types.BIT);
            else
                _ps.setInt(13, cu_allowreferenceduplicates? 1: 0);
            
            String cu_referencevalidationpattern = _value.getReferenceValidationPattern();
            if(cu_referencevalidationpattern == null)
                _ps.setNull(14, Types.VARCHAR);
            else
                _ps.setString(14, cu_referencevalidationpattern);
            
            Long cu_fromtime = _value.getFromTime();
            if(cu_fromtime == null)
                _ps.setNull(15, Types.BIGINT);
            else
                _ps.setLong(15, cu_fromtime);
            
            Long cu_thrutime = _value.getThruTime();
            if(cu_thrutime == null)
                _ps.setNull(16, Types.BIGINT);
            else
                _ps.setLong(16, cu_thrutime);
            
            _ps.setLong(17, _value.getPrimaryKey().getEntityId());
            
            _value.clearHasBeenModified();
        }
        
        return _hasBeenModified;
    }
    
    @Override
    public void store(Customer entity)
            throws PersistenceDatabaseException {
        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
        
        try {
            CustomerValue _value = entity.getCustomerValue();
            
            if(bindForStore(_ps, _value)) {
                if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
                    int _count = _ps.executeUpdate();
                    
                    if(_count != 1) {
                        throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count);
                    }
                } else {
                     _ps.executeUpdate();
                }
                
                session.getValueCache().put(_value);
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
    }
    
    @Override
    public void store(Collection<Customer> entities)
            throws PersistenceDatabaseException {
        if(entities.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
            int _modifiedEntities = 0;
            
            try {
                for(Customer entity : entities) {
                    if(bindForStore(_ps, entity.getCustomerValue())) {
                        _ps.addBatch();
                        _modifiedEntities++;
                    }
                }
                
                if(_modifiedEntities != 0) {
                    if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
                        int[] _counts = _ps.executeBatch();
                        
                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
                                throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
                            }
                        }
                    } else {
                         _ps.executeBatch();
                    }
                    
                    _ps.clearBatch();
                    
                    entities.forEach((entity) -> {
                        session.getValueCache().put(entity.getCustomerValue());
                    });
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
        }
    }
    
    @Override
    public void remove(Customer entity)
            throws PersistenceDatabaseException {
        remove(entity.getPrimaryKey());
    }
    
    @Override
    public void remove(CustomerPK pk)
            throws PersistenceDatabaseException {
        PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
        long _entityId = pk.getEntityId();
        
        try {
            _ps.setLong(1, _entityId);
            
            if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
                int _count = _ps.executeUpdate();
                
                if(_count != 1) {
                    throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count);
                }
            } else {
                 _ps.executeUpdate();
            }
            
            session.getValueCache().remove(pk);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        session.removed(pk, false);
    }
    
    @Override
    public void remove(Collection<CustomerPK> pks)
            throws PersistenceDatabaseException {
        if(pks.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
            int _modifiedEntities = 0;
            
            try {
                for(CustomerPK pk : pks) {
                    long _entityId = pk.getEntityId();
                    
                    _ps.setLong(1, _entityId);
                    
                    _ps.addBatch();
                    _modifiedEntities++;
                }
                
                if(_modifiedEntities != 0) {
                    if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
                        int[] _counts = _ps.executeBatch();
                        
                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
                                throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
                            }
                        }
                    } else {
                        _ps.executeBatch();
                    }
                    
                    _ps.clearBatch();
                    
                    pks.forEach((pk) -> {
                        session.getValueCache().remove(pk);
                    });
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
            
            pks.forEach((pk) -> {
                session.removed(pk, true);
            });
        }
    }
    
    @Override
    public boolean validPK(CustomerPK pk)
            throws PersistenceDatabaseException {
        boolean valid = false;
        PreparedStatement _ps = session.prepareStatement(SQL_VALID);
        ResultSet _rs = null;
        
        try {
            _ps.setLong(1, pk.getEntityId());
            
            _rs = _ps.executeQuery();
            if(_rs.next()) {
                long _count = _rs.getLong(1);
                if(_rs.wasNull())
                    _count = 0;
                
                if(_count == 1)
                    valid = true;
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return valid;
    }
    
}