Source code

001// --------------------------------------------------------------------------------
002// Copyright 2002-2026 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016// Generated File -- DO NOT EDIT BY HAND
017// --------------------------------------------------------------------------------
018
019/**
020 * PaymentProcessorDetailFactory.java
021 */
022
023package com.echothree.model.data.payment.server.factory;
024
025import com.echothree.model.data.payment.common.pk.PaymentProcessorPK;
026import com.echothree.model.data.payment.common.pk.PaymentProcessorTypePK;
027
028import com.echothree.model.data.payment.server.entity.PaymentProcessor;
029import com.echothree.model.data.payment.server.entity.PaymentProcessorType;
030
031import com.echothree.model.data.payment.common.PaymentProcessorDetailConstants;
032import com.echothree.model.data.payment.common.pk.PaymentProcessorDetailPK;
033import com.echothree.model.data.payment.server.value.PaymentProcessorDetailValue;
034import com.echothree.model.data.payment.server.entity.PaymentProcessorDetail;
035import com.echothree.util.common.exception.PersistenceDatabaseException;
036import com.echothree.util.common.exception.PersistenceDatabaseUpdateException;
037import com.echothree.util.common.exception.PersistenceNotNullException;
038import com.echothree.util.server.persistence.BaseFactory;
039import com.echothree.util.server.persistence.EntityIdGenerator;
040import com.echothree.util.server.persistence.EntityPermission;
041import com.echothree.util.server.persistence.PersistenceDebugFlags;
042import com.echothree.util.server.persistence.Session;
043import java.sql.PreparedStatement;
044import java.sql.ResultSet;
045import java.sql.SQLException;
046import java.sql.Types;
047import java.io.ByteArrayInputStream;
048import java.io.StringReader;
049import java.util.ArrayList;
050import java.util.Collection;
051import java.util.HashSet;
052import java.util.List;
053import java.util.Map;
054import java.util.Set;
055import javax.enterprise.context.ApplicationScoped;
056import javax.enterprise.inject.spi.CDI;
057import javax.inject.Inject;
058import org.jooq.ResultQuery;
059import org.slf4j.Logger;
060import org.slf4j.LoggerFactory;
061
062@ApplicationScoped
063public class PaymentProcessorDetailFactory
064        implements BaseFactory<PaymentProcessorDetailPK, PaymentProcessorDetail> {
065    
066    @Inject
067    Session session;
068    
069    //private static final Logger log = LoggerFactory.getLogger(PaymentProcessorDetailFactory.class);
070    
071    final private static String SQL_SELECT_READ_ONLY = "SELECT pprcdt_paymentprocessordetailid, pprcdt_pprc_paymentprocessorid, pprcdt_paymentprocessorname, pprcdt_pprctyp_paymentprocessortypeid, pprcdt_isdefault, pprcdt_sortorder, pprcdt_fromtime, pprcdt_thrutime FROM paymentprocessordetails WHERE pprcdt_paymentprocessordetailid = ?";
072    final private static String SQL_SELECT_READ_WRITE = "SELECT pprcdt_paymentprocessordetailid, pprcdt_pprc_paymentprocessorid, pprcdt_paymentprocessorname, pprcdt_pprctyp_paymentprocessortypeid, pprcdt_isdefault, pprcdt_sortorder, pprcdt_fromtime, pprcdt_thrutime FROM paymentprocessordetails WHERE pprcdt_paymentprocessordetailid = ? FOR UPDATE";
073    final private static String SQL_INSERT = "INSERT INTO paymentprocessordetails (pprcdt_paymentprocessordetailid, pprcdt_pprc_paymentprocessorid, pprcdt_paymentprocessorname, pprcdt_pprctyp_paymentprocessortypeid, pprcdt_isdefault, pprcdt_sortorder, pprcdt_fromtime, pprcdt_thrutime) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
074    final private static String SQL_UPDATE = "UPDATE paymentprocessordetails SET pprcdt_pprc_paymentprocessorid = ?, pprcdt_paymentprocessorname = ?, pprcdt_pprctyp_paymentprocessortypeid = ?, pprcdt_isdefault = ?, pprcdt_sortorder = ?, pprcdt_fromtime = ?, pprcdt_thrutime = ? WHERE pprcdt_paymentprocessordetailid = ?";
075    final private static String SQL_DELETE = "DELETE FROM paymentprocessordetails WHERE pprcdt_paymentprocessordetailid = ?";
076    final private static String SQL_VALID = "SELECT COUNT(*) FROM paymentprocessordetails WHERE pprcdt_paymentprocessordetailid = ?";
077    
078    final public static String PPRCDT_PAYMENTPROCESSORDETAILID = "pprcdt_paymentprocessordetailid";
079    final public static String PPRCDT_PPRC_PAYMENTPROCESSORID = "pprcdt_pprc_paymentprocessorid";
080    final public static String PPRCDT_PAYMENTPROCESSORNAME = "pprcdt_paymentprocessorname";
081    final public static String PPRCDT_PPRCTYP_PAYMENTPROCESSORTYPEID = "pprcdt_pprctyp_paymentprocessortypeid";
082    final public static String PPRCDT_ISDEFAULT = "pprcdt_isdefault";
083    final public static String PPRCDT_SORTORDER = "pprcdt_sortorder";
084    final public static String PPRCDT_FROMTIME = "pprcdt_fromtime";
085    final public static String PPRCDT_THRUTIME = "pprcdt_thrutime";
086    
087    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(PaymentProcessorDetailConstants.COMPONENT_VENDOR_NAME, PaymentProcessorDetailConstants.ENTITY_TYPE_NAME);
088    
089    /** Creates a new instance of PaymentProcessorDetailFactory */
090    protected PaymentProcessorDetailFactory() {
091        super();
092    }
093    
094    public static PaymentProcessorDetailFactory getInstance() {
095        return CDI.current().select(PaymentProcessorDetailFactory.class).get();
096    }
097    
098    @Override
099    public String getComponentVendorName() {
100        return PaymentProcessorDetailConstants.COMPONENT_VENDOR_NAME;
101    }
102    
103    @Override
104    public String getEntityTypeName() {
105        return PaymentProcessorDetailConstants.ENTITY_TYPE_NAME;
106    }
107    
108    public PreparedStatement prepareStatement(String query) {
109        return session.prepareStatement(query);
110    }
111    
112    public PaymentProcessorDetailPK getNextPK() {
113        return new PaymentProcessorDetailPK(entityIdGenerator.getNextEntityId());
114    }
115    
116    public Set<PaymentProcessorDetailPK> getPKsFromResultSetAsSet(ResultSet rs)
117            throws PersistenceDatabaseException {
118        Set<PaymentProcessorDetailPK> _result = new HashSet<>();
119        
120        try {
121            while(rs.next()) {
122                _result.add(getPKFromResultSet(rs));
123            }
124        } catch (SQLException se) {
125            throw new PersistenceDatabaseException(se);
126        }
127        
128        return _result;
129    }
130    
131    public java.util.List<PaymentProcessorDetailPK> getPKsFromResultSetAsList(ResultSet rs)
132            throws PersistenceDatabaseException {
133        java.util.List<PaymentProcessorDetailPK> _result = new ArrayList<>();
134        
135        try {
136            while(rs.next()) {
137                _result.add(getPKFromResultSet(rs));
138            }
139        } catch (SQLException se) {
140            throw new PersistenceDatabaseException(se);
141        }
142        
143        return _result;
144    }
145    
146    public PaymentProcessorDetailPK getPKFromResultSet(ResultSet rs)
147            throws PersistenceDatabaseException {
148        PaymentProcessorDetailPK _result;
149        
150        try {
151            long pprcdt_paymentprocessordetailid = rs.getLong(PPRCDT_PAYMENTPROCESSORDETAILID);
152            Long _entityId = rs.wasNull() ? null : pprcdt_paymentprocessordetailid;
153            
154            _result = new PaymentProcessorDetailPK(_entityId);
155        } catch (SQLException se) {
156            throw new PersistenceDatabaseException(se);
157        }
158        
159        return _result;
160    }
161    
162    public java.util.List<PaymentProcessorDetailValue> getValuesFromPKs(Collection<PaymentProcessorDetailPK> pks)
163            throws PersistenceDatabaseException {
164        java.util.List<PaymentProcessorDetailValue> _values = new ArrayList<>(pks.size());
165        
166        for(PaymentProcessorDetailPK _pk: pks) {
167            _values.add(getValueFromPK(_pk));
168        }
169        
170        return _values;
171    }
172    
173    public PaymentProcessorDetailValue getValueFromPK(PaymentProcessorDetailPK pk)
174            throws PersistenceDatabaseException {
175        PaymentProcessorDetailValue _value;
176        
177        // See if we already have the entity in the session cache
178        PaymentProcessorDetail _entity = (PaymentProcessorDetail)session.getEntity(pk);
179        if(_entity == null)
180            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getPaymentProcessorDetailValue();
181        else
182            _value = _entity.getPaymentProcessorDetailValue();
183        
184        return _value;
185    }
186    
187    public java.util.List<PaymentProcessorDetailValue> getValuesFromResultSet(ResultSet rs)
188            throws PersistenceDatabaseException {
189        java.util.List<PaymentProcessorDetailValue> _result = new ArrayList<>();
190        
191        try {
192            while(rs.next()) {
193                _result.add(getValueFromResultSet(rs));
194            }
195        } catch (SQLException se) {
196            throw new PersistenceDatabaseException(se);
197        }
198        
199        return _result;
200    }
201    
202    public PaymentProcessorDetailValue getValueFromResultSet(ResultSet rs)
203            throws PersistenceDatabaseException {
204        PaymentProcessorDetailValue _value;
205        
206        try {
207            Long pprcdt_paymentprocessordetailid = rs.getLong(PPRCDT_PAYMENTPROCESSORDETAILID);
208            PaymentProcessorDetailPK _pk = new PaymentProcessorDetailPK(pprcdt_paymentprocessordetailid);
209            
210            // See if we already have the entity in the session cache
211            PaymentProcessorDetail _entity = (PaymentProcessorDetail)session.getEntity(_pk);
212            
213            if(_entity == null) {
214                Long pprcdt_pprc_paymentprocessorid = rs.getLong(PPRCDT_PPRC_PAYMENTPROCESSORID);
215                if(rs.wasNull())
216                    pprcdt_pprc_paymentprocessorid = null;
217                
218                String pprcdt_paymentprocessorname = rs.getString(PPRCDT_PAYMENTPROCESSORNAME);
219                if(rs.wasNull())
220                    pprcdt_paymentprocessorname = null;
221                
222                Long pprcdt_pprctyp_paymentprocessortypeid = rs.getLong(PPRCDT_PPRCTYP_PAYMENTPROCESSORTYPEID);
223                if(rs.wasNull())
224                    pprcdt_pprctyp_paymentprocessortypeid = null;
225                
226                Boolean pprcdt_isdefault = rs.getInt(PPRCDT_ISDEFAULT) == 1;
227                if(rs.wasNull())
228                    pprcdt_isdefault = null;
229                
230                Integer pprcdt_sortorder = rs.getInt(PPRCDT_SORTORDER);
231                if(rs.wasNull())
232                    pprcdt_sortorder = null;
233                
234                Long pprcdt_fromtime = rs.getLong(PPRCDT_FROMTIME);
235                if(rs.wasNull())
236                    pprcdt_fromtime = null;
237                
238                Long pprcdt_thrutime = rs.getLong(PPRCDT_THRUTIME);
239                if(rs.wasNull())
240                    pprcdt_thrutime = null;
241                
242                _value = new PaymentProcessorDetailValue(_pk, new PaymentProcessorPK(pprcdt_pprc_paymentprocessorid), pprcdt_paymentprocessorname, new PaymentProcessorTypePK(pprcdt_pprctyp_paymentprocessortypeid), pprcdt_isdefault, pprcdt_sortorder, pprcdt_fromtime, pprcdt_thrutime);
243            } else
244                _value = _entity.getPaymentProcessorDetailValue();
245        } catch (SQLException se) {
246            throw new PersistenceDatabaseException(se);
247        }
248        
249        return _value;
250    }
251    
252    public java.util.List<PaymentProcessorDetail> getEntitiesFromPKs(EntityPermission entityPermission, Collection<PaymentProcessorDetailPK> pks)
253            throws PersistenceDatabaseException {
254        java.util.List<PaymentProcessorDetail> _entities = new ArrayList<>(pks.size());
255        
256        for(PaymentProcessorDetailPK _pk: pks) {
257            _entities.add(getEntityFromPK(entityPermission, _pk));
258        }
259        
260        return _entities;
261    }
262    
263    public PaymentProcessorDetail getEntityFromValue(EntityPermission entityPermission, PaymentProcessorDetailValue value) {
264        return getEntityFromPK(entityPermission, value.getPrimaryKey());
265    }
266    
267    public PaymentProcessorDetail getEntityFromCache(PaymentProcessorDetailPK pk) {
268        PaymentProcessorDetailValue _value = (PaymentProcessorDetailValue)session.getValueCache().get(pk);
269    
270        return _value == null ? null : new PaymentProcessorDetail(_value, EntityPermission.READ_ONLY);
271    }
272    
273    public PaymentProcessorDetail getEntityFromPK(EntityPermission entityPermission, PaymentProcessorDetailPK pk)
274            throws PersistenceDatabaseException {
275        PaymentProcessorDetail _entity;
276        
277        // See if we already have the entity in the session cache
278        _entity = (PaymentProcessorDetail)session.getEntity(pk);
279        if(_entity != null) {
280            // If the requested permission is READ_WRITE, and the cached permission is
281            // READ_ONLY, then pretend that the cached object wasn't found, and create
282            // a new entity that is READ_WRITE.
283            if(entityPermission.equals(EntityPermission.READ_WRITE)) {
284                if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
285                    _entity = null;
286            }
287        }
288        
289        if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
290            _entity = getEntityFromCache(pk);
291        }
292        
293        if(_entity == null) {
294            PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE);
295            long _entityId = pk.getEntityId();
296            ResultSet _rs = null;
297            
298            try {
299                _ps.setLong(1, _entityId);
300                _rs = _ps.executeQuery();
301                if(_rs.next()) {
302                    _entity = getEntityFromResultSet(entityPermission, _rs);
303                }
304            } catch (SQLException se) {
305                throw new PersistenceDatabaseException(se);
306            } finally {
307                if(_rs != null) {
308                    try {
309                        _rs.close();
310                    } catch (SQLException se) {
311                        // do nothing
312                    }
313                }
314            }
315        }
316        
317        return _entity;
318    }
319    
320    public Set<PaymentProcessorDetailPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
321            throws PersistenceDatabaseException {
322        Set<PaymentProcessorDetailPK> _pks;
323        ResultSet _rs = null;
324        
325        try {
326            if(params.length != 0) {
327                Session.setQueryParams(ps, params);
328            }
329            
330            _rs = ps.executeQuery();
331            _pks = getPKsFromResultSetAsSet(_rs);
332            _rs.close();
333        } catch (SQLException se) {
334            throw new PersistenceDatabaseException(se);
335        } finally {
336            if(_rs != null) {
337                try {
338                    _rs.close();
339                } catch (SQLException se) {
340                    // do nothing
341                }
342            }
343        }
344        
345        return _pks;
346    }
347    
348    public java.util.List<PaymentProcessorDetailPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
349            throws PersistenceDatabaseException {
350        java.util.List<PaymentProcessorDetailPK> _pks;
351        ResultSet _rs = null;
352        
353        try {
354            if(params.length != 0) {
355                Session.setQueryParams(ps, params);
356            }
357            
358            _rs = ps.executeQuery();
359            _pks = getPKsFromResultSetAsList(_rs);
360            _rs.close();
361        } catch (SQLException se) {
362            throw new PersistenceDatabaseException(se);
363        } finally {
364            if(_rs != null) {
365                try {
366                    _rs.close();
367                } catch (SQLException se) {
368                    // do nothing
369                }
370            }
371        }
372        
373        return _pks;
374    }
375    
376    public PaymentProcessorDetailPK getPKFromQuery(PreparedStatement ps, final Object... params)
377            throws PersistenceDatabaseException {
378        PaymentProcessorDetailPK _pk = null;
379        ResultSet _rs = null;
380        
381        try {
382            if(params.length != 0) {
383                Session.setQueryParams(ps, params);
384            }
385            
386            _rs = ps.executeQuery();
387            if(_rs.next()) {
388                _pk = getPKFromResultSet(_rs);
389            }
390            _rs.close();
391        } catch (SQLException se) {
392            throw new PersistenceDatabaseException(se);
393        } finally {
394            if(_rs != null) {
395                try {
396                    _rs.close();
397                } catch (SQLException se) {
398                    // do nothing
399                }
400            }
401        }
402        
403        return _pk;
404    }
405    
406    public java.util.List<PaymentProcessorDetail> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
407            throws PersistenceDatabaseException {
408        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
409        
410        return getEntitiesFromQuery(entityPermission, ps, params);
411    }
412    
413    public java.util.List<PaymentProcessorDetail> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
414            throws PersistenceDatabaseException {
415        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
416        
417        return getEntitiesFromQuery(entityPermission, ps);
418    }
419    
420    public java.util.List<PaymentProcessorDetail> getEntitiesFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
421            throws PersistenceDatabaseException {
422        PreparedStatement ps = session.prepareStatement(query.getSQL());
423        
424        return getEntitiesFromQuery(entityPermission, ps, query.getBindValues().toArray());
425    }
426    
427    public java.util.List<PaymentProcessorDetail> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
428            throws PersistenceDatabaseException {
429        java.util.List<PaymentProcessorDetail> _entities;
430        ResultSet _rs = null;
431        
432        try {
433            if(params.length != 0) {
434                Session.setQueryParams(ps, params);
435            }
436            
437            _rs = ps.executeQuery();
438            _entities = getEntitiesFromResultSet(entityPermission, _rs);
439            _rs.close();
440        } catch (SQLException se) {
441            throw new PersistenceDatabaseException(se);
442        } finally {
443            if(_rs != null) {
444                try {
445                    _rs.close();
446                } catch (SQLException se) {
447                    // do nothing
448                }
449            }
450        }
451        
452        return _entities;
453    }
454    
455    public PaymentProcessorDetail getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
456            throws PersistenceDatabaseException {
457        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
458        
459        return getEntityFromQuery(entityPermission, ps, params);
460    }
461    
462    public PaymentProcessorDetail getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
463            throws PersistenceDatabaseException {
464        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
465        
466        return getEntityFromQuery(entityPermission, ps);
467    }
468    
469    public PaymentProcessorDetail getEntityFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
470            throws PersistenceDatabaseException {
471        PreparedStatement ps = session.prepareStatement(query.getSQL());
472        
473        return getEntityFromQuery(entityPermission, ps, query.getBindValues().toArray());
474    }
475    
476    public PaymentProcessorDetail getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
477            throws PersistenceDatabaseException {
478        PaymentProcessorDetail _entity = null;
479        ResultSet _rs = null;
480        
481        try {
482            if(params.length != 0) {
483                Session.setQueryParams(ps, params);
484            }
485            
486            _rs = ps.executeQuery();
487            if(_rs.next()) {
488                _entity = getEntityFromResultSet(entityPermission, _rs);
489            }
490            _rs.close();
491        } catch (SQLException se) {
492            throw new PersistenceDatabaseException(se);
493        } finally {
494            if(_rs != null) {
495                try {
496                    _rs.close();
497                } catch (SQLException se) {
498                    // do nothing
499                }
500            }
501        }
502        
503        return _entity;
504    }
505    
506    public java.util.List<PaymentProcessorDetail> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
507            throws PersistenceDatabaseException {
508        java.util.List<PaymentProcessorDetail> _result = new ArrayList<>();
509        
510        try {
511            while(rs.next()) {
512                _result.add(getEntityFromResultSet(entityPermission, rs));
513            }
514        } catch (SQLException se) {
515            throw new PersistenceDatabaseException(se);
516        }
517        
518        return _result;
519    }
520    
521    public PaymentProcessorDetail getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
522            throws PersistenceDatabaseException {
523        PaymentProcessorDetail _entity;
524        
525        try {
526            Long pprcdt_paymentprocessordetailid = rs.getLong(PPRCDT_PAYMENTPROCESSORDETAILID);
527            PaymentProcessorDetailPK _pk = new PaymentProcessorDetailPK(pprcdt_paymentprocessordetailid);
528            
529            // See if we already have the entity in the session cache
530            _entity = (PaymentProcessorDetail)session.getEntity(_pk);
531            if(_entity != null) {
532                // If the requested permission is READ_WRITE, and the cached permission is
533                // READ_ONLY, then pretend that the cached object wasn't found, and create
534                // a new entity that is READ_WRITE.
535                if(entityPermission.equals(EntityPermission.READ_WRITE)) {
536                    if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
537                        _entity = null;
538                }
539            }
540            boolean foundInSessionCache = _entity != null;
541            
542            if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
543                _entity = getEntityFromCache(_pk);
544            }
545            
546            if(_entity == null) {
547                Long pprcdt_pprc_paymentprocessorid = rs.getLong(PPRCDT_PPRC_PAYMENTPROCESSORID);
548                if(rs.wasNull())
549                    pprcdt_pprc_paymentprocessorid = null;
550                
551                String pprcdt_paymentprocessorname = rs.getString(PPRCDT_PAYMENTPROCESSORNAME);
552                if(rs.wasNull())
553                    pprcdt_paymentprocessorname = null;
554                
555                Long pprcdt_pprctyp_paymentprocessortypeid = rs.getLong(PPRCDT_PPRCTYP_PAYMENTPROCESSORTYPEID);
556                if(rs.wasNull())
557                    pprcdt_pprctyp_paymentprocessortypeid = null;
558                
559                Boolean pprcdt_isdefault = rs.getInt(PPRCDT_ISDEFAULT) == 1;
560                if(rs.wasNull())
561                    pprcdt_isdefault = null;
562                
563                Integer pprcdt_sortorder = rs.getInt(PPRCDT_SORTORDER);
564                if(rs.wasNull())
565                    pprcdt_sortorder = null;
566                
567                Long pprcdt_fromtime = rs.getLong(PPRCDT_FROMTIME);
568                if(rs.wasNull())
569                    pprcdt_fromtime = null;
570                
571                Long pprcdt_thrutime = rs.getLong(PPRCDT_THRUTIME);
572                if(rs.wasNull())
573                    pprcdt_thrutime = null;
574                
575                PaymentProcessorDetailValue _value = new PaymentProcessorDetailValue(_pk, pprcdt_pprc_paymentprocessorid == null? null: new PaymentProcessorPK(pprcdt_pprc_paymentprocessorid), pprcdt_paymentprocessorname, pprcdt_pprctyp_paymentprocessortypeid == null? null: new PaymentProcessorTypePK(pprcdt_pprctyp_paymentprocessortypeid), pprcdt_isdefault, pprcdt_sortorder, pprcdt_fromtime, pprcdt_thrutime);
576                _entity = new PaymentProcessorDetail(_value, entityPermission);
577            }
578            
579            if(!foundInSessionCache) {
580                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
581                    session.putReadOnlyEntity(_pk, _entity);
582                    session.getValueCache().put(_entity.getPaymentProcessorDetailValue());
583                } else {
584                    session.putReadWriteEntity(_pk, _entity);
585                }
586            }
587        } catch (SQLException se) {
588            throw new PersistenceDatabaseException(se);
589        }
590        
591        return _entity;
592    }
593    
594    public PaymentProcessorDetail create(PaymentProcessor paymentProcessor, String paymentProcessorName, PaymentProcessorType paymentProcessorType, Boolean isDefault, Integer sortOrder, Long fromTime, Long thruTime)
595            throws PersistenceDatabaseException, PersistenceNotNullException {
596        return create(paymentProcessor == null ? null : paymentProcessor.getPrimaryKey(), paymentProcessorName, paymentProcessorType == null ? null : paymentProcessorType.getPrimaryKey(), isDefault, sortOrder, fromTime, thruTime);
597    }
598    
599    private void bindForCreate(PreparedStatement _ps, PaymentProcessorDetailValue _value)
600            throws SQLException {
601        _ps.setLong(1, _value.getEntityId());
602        
603        PaymentProcessorPK pprcdt_pprc_paymentprocessorid = _value.getPaymentProcessorPK();
604        if(pprcdt_pprc_paymentprocessorid == null)
605            _ps.setNull(2, Types.BIGINT);
606        else
607            _ps.setLong(2, pprcdt_pprc_paymentprocessorid.getEntityId());
608            
609        String pprcdt_paymentprocessorname = _value.getPaymentProcessorName();
610        if(pprcdt_paymentprocessorname == null)
611            _ps.setNull(3, Types.VARCHAR);
612        else
613            _ps.setString(3, pprcdt_paymentprocessorname);
614            
615        PaymentProcessorTypePK pprcdt_pprctyp_paymentprocessortypeid = _value.getPaymentProcessorTypePK();
616        if(pprcdt_pprctyp_paymentprocessortypeid == null)
617            _ps.setNull(4, Types.BIGINT);
618        else
619            _ps.setLong(4, pprcdt_pprctyp_paymentprocessortypeid.getEntityId());
620            
621        Boolean pprcdt_isdefault = _value.getIsDefault();
622        if(pprcdt_isdefault == null)
623            _ps.setNull(5, Types.BIT);
624        else
625            _ps.setInt(5, pprcdt_isdefault? 1: 0);
626            
627        Integer pprcdt_sortorder = _value.getSortOrder();
628        if(pprcdt_sortorder == null)
629            _ps.setNull(6, Types.INTEGER);
630        else
631            _ps.setInt(6, pprcdt_sortorder);
632            
633        Long pprcdt_fromtime = _value.getFromTime();
634        if(pprcdt_fromtime == null)
635            _ps.setNull(7, Types.BIGINT);
636        else
637            _ps.setLong(7, pprcdt_fromtime);
638            
639        Long pprcdt_thrutime = _value.getThruTime();
640        if(pprcdt_thrutime == null)
641            _ps.setNull(8, Types.BIGINT);
642        else
643            _ps.setLong(8, pprcdt_thrutime);
644            
645    }
646    
647    public PaymentProcessorDetail create(PaymentProcessorPK paymentProcessorPK, String paymentProcessorName, PaymentProcessorTypePK paymentProcessorTypePK, Boolean isDefault, Integer sortOrder, Long fromTime, Long thruTime)
648            throws PersistenceDatabaseException, PersistenceNotNullException {
649        PaymentProcessorDetailPK _pk = getNextPK();
650        PaymentProcessorDetailValue _value = new PaymentProcessorDetailValue(_pk, paymentProcessorPK, paymentProcessorName, paymentProcessorTypePK, isDefault, sortOrder, fromTime, thruTime);
651        
652        PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
653        
654        try {
655            bindForCreate(_ps, _value);
656            
657            if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
658                int _count = _ps.executeUpdate();
659                
660                if(_count != 1) {
661                    throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count);
662                }
663            } else {
664                 _ps.executeUpdate();
665            }
666            
667            session.getValueCache().put(_value);
668        } catch (SQLException se) {
669            throw new PersistenceDatabaseException(se);
670        }
671        
672        PaymentProcessorDetail _entity = new PaymentProcessorDetail(_value, EntityPermission.READ_ONLY);
673        session.putReadOnlyEntity(_pk, _entity);
674        
675        return _entity;
676    }
677    
678    public void create(Collection<PaymentProcessorDetailValue> _values)
679            throws PersistenceDatabaseException, PersistenceNotNullException {
680        int _size = _values.size();
681        
682        if(_size > 0) {
683            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
684            List<PaymentProcessorDetailValue> _cacheValues = new ArrayList<>(_size);
685            
686            try {
687                for(PaymentProcessorDetailValue _value : _values) {
688                    _value.setEntityId(entityIdGenerator.getNextEntityId());
689                    bindForCreate(_ps, _value);
690                    
691                    _ps.addBatch();
692                    
693                    _cacheValues.add(_value);
694                }
695                
696                if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
697                    int[] _counts = _ps.executeBatch();
698                    
699                    for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) {
700                        if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
701                            throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
702                        }
703                    }
704                } else {
705                     _ps.executeBatch();
706                }
707                
708                _ps.clearBatch();
709            } catch (SQLException se) {
710                throw new PersistenceDatabaseException(se);
711            }
712            
713            _cacheValues.forEach((_cacheValue) -> {
714                PaymentProcessorDetail _cacheEntity = new PaymentProcessorDetail(_cacheValue, EntityPermission.READ_ONLY);
715                
716                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
717            });
718        }
719    }
720    
721    private boolean bindForStore(PreparedStatement _ps, PaymentProcessorDetailValue _value)
722            throws SQLException {
723        boolean _hasBeenModified = _value.hasBeenModified();
724        
725        if(_hasBeenModified) {
726            PaymentProcessorPK pprcdt_pprc_paymentprocessorid = _value.getPaymentProcessorPK();
727            if(pprcdt_pprc_paymentprocessorid == null)
728                _ps.setNull(1, Types.BIGINT);
729            else
730                _ps.setLong(1, pprcdt_pprc_paymentprocessorid.getEntityId());
731            
732            String pprcdt_paymentprocessorname = _value.getPaymentProcessorName();
733            if(pprcdt_paymentprocessorname == null)
734                _ps.setNull(2, Types.VARCHAR);
735            else
736                _ps.setString(2, pprcdt_paymentprocessorname);
737            
738            PaymentProcessorTypePK pprcdt_pprctyp_paymentprocessortypeid = _value.getPaymentProcessorTypePK();
739            if(pprcdt_pprctyp_paymentprocessortypeid == null)
740                _ps.setNull(3, Types.BIGINT);
741            else
742                _ps.setLong(3, pprcdt_pprctyp_paymentprocessortypeid.getEntityId());
743            
744            Boolean pprcdt_isdefault = _value.getIsDefault();
745            if(pprcdt_isdefault == null)
746                _ps.setNull(4, Types.BIT);
747            else
748                _ps.setInt(4, pprcdt_isdefault? 1: 0);
749            
750            Integer pprcdt_sortorder = _value.getSortOrder();
751            if(pprcdt_sortorder == null)
752                _ps.setNull(5, Types.INTEGER);
753            else
754                _ps.setInt(5, pprcdt_sortorder);
755            
756            Long pprcdt_fromtime = _value.getFromTime();
757            if(pprcdt_fromtime == null)
758                _ps.setNull(6, Types.BIGINT);
759            else
760                _ps.setLong(6, pprcdt_fromtime);
761            
762            Long pprcdt_thrutime = _value.getThruTime();
763            if(pprcdt_thrutime == null)
764                _ps.setNull(7, Types.BIGINT);
765            else
766                _ps.setLong(7, pprcdt_thrutime);
767            
768            _ps.setLong(8, _value.getPrimaryKey().getEntityId());
769            
770            _value.clearHasBeenModified();
771        }
772        
773        return _hasBeenModified;
774    }
775    
776    @Override
777    public void store(PaymentProcessorDetail entity)
778            throws PersistenceDatabaseException {
779        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
780        
781        try {
782            PaymentProcessorDetailValue _value = entity.getPaymentProcessorDetailValue();
783            
784            if(bindForStore(_ps, _value)) {
785                if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
786                    int _count = _ps.executeUpdate();
787                    
788                    if(_count != 1) {
789                        throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count);
790                    }
791                } else {
792                     _ps.executeUpdate();
793                }
794                
795                session.getValueCache().put(_value);
796            }
797        } catch (SQLException se) {
798            throw new PersistenceDatabaseException(se);
799        }
800    }
801    
802    @Override
803    public void store(Collection<PaymentProcessorDetail> entities)
804            throws PersistenceDatabaseException {
805        if(entities.size() > 0) {
806            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
807            int _modifiedEntities = 0;
808            
809            try {
810                for(PaymentProcessorDetail entity : entities) {
811                    if(bindForStore(_ps, entity.getPaymentProcessorDetailValue())) {
812                        _ps.addBatch();
813                        _modifiedEntities++;
814                    }
815                }
816                
817                if(_modifiedEntities != 0) {
818                    if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
819                        int[] _counts = _ps.executeBatch();
820                        
821                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
822                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
823                                throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
824                            }
825                        }
826                    } else {
827                         _ps.executeBatch();
828                    }
829                    
830                    _ps.clearBatch();
831                    
832                    entities.forEach((entity) -> {
833                        session.getValueCache().put(entity.getPaymentProcessorDetailValue());
834                    });
835                }
836            } catch (SQLException se) {
837                throw new PersistenceDatabaseException(se);
838            }
839        }
840    }
841    
842    @Override
843    public void remove(PaymentProcessorDetail entity)
844            throws PersistenceDatabaseException {
845        remove(entity.getPrimaryKey());
846    }
847    
848    @Override
849    public void remove(PaymentProcessorDetailPK pk)
850            throws PersistenceDatabaseException {
851        PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
852        long _entityId = pk.getEntityId();
853        
854        try {
855            _ps.setLong(1, _entityId);
856            
857            if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
858                int _count = _ps.executeUpdate();
859                
860                if(_count != 1) {
861                    throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count);
862                }
863            } else {
864                 _ps.executeUpdate();
865            }
866            
867            session.getValueCache().remove(pk);
868        } catch (SQLException se) {
869            throw new PersistenceDatabaseException(se);
870        }
871        
872        session.removed(pk, false);
873    }
874    
875    @Override
876    public void remove(Collection<PaymentProcessorDetailPK> pks)
877            throws PersistenceDatabaseException {
878        if(pks.size() > 0) {
879            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
880            int _modifiedEntities = 0;
881            
882            try {
883                for(PaymentProcessorDetailPK pk : pks) {
884                    long _entityId = pk.getEntityId();
885                    
886                    _ps.setLong(1, _entityId);
887                    
888                    _ps.addBatch();
889                    _modifiedEntities++;
890                }
891                
892                if(_modifiedEntities != 0) {
893                    if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
894                        int[] _counts = _ps.executeBatch();
895                        
896                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
897                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
898                                throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
899                            }
900                        }
901                    } else {
902                        _ps.executeBatch();
903                    }
904                    
905                    _ps.clearBatch();
906                    
907                    pks.forEach((pk) -> {
908                        session.getValueCache().remove(pk);
909                    });
910                }
911            } catch (SQLException se) {
912                throw new PersistenceDatabaseException(se);
913            }
914            
915            pks.forEach((pk) -> {
916                session.removed(pk, true);
917            });
918        }
919    }
920    
921    @Override
922    public boolean validPK(PaymentProcessorDetailPK pk)
923            throws PersistenceDatabaseException {
924        boolean valid = false;
925        PreparedStatement _ps = session.prepareStatement(SQL_VALID);
926        ResultSet _rs = null;
927        
928        try {
929            _ps.setLong(1, pk.getEntityId());
930            
931            _rs = _ps.executeQuery();
932            if(_rs.next()) {
933                long _count = _rs.getLong(1);
934                if(_rs.wasNull())
935                    _count = 0;
936                
937                if(_count == 1)
938                    valid = true;
939            }
940        } catch (SQLException se) {
941            throw new PersistenceDatabaseException(se);
942        } finally {
943            if(_rs != null) {
944                try {
945                    _rs.close();
946                } catch (SQLException se) {
947                    // do nothing
948                }
949            }
950        }
951        
952        return valid;
953    }
954    
955}