001// -------------------------------------------------------------------------------- 002// Copyright 2002-2024 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 * PaymentMethodCreditCardFactory.java 021 */ 022 023package com.echothree.model.data.payment.server.factory; 024 025import com.echothree.model.data.payment.common.pk.PaymentMethodPK; 026 027import com.echothree.model.data.payment.server.entity.PaymentMethod; 028 029import com.echothree.model.data.payment.common.PaymentMethodCreditCardConstants; 030import com.echothree.model.data.payment.common.pk.PaymentMethodCreditCardPK; 031import com.echothree.model.data.payment.server.value.PaymentMethodCreditCardValue; 032import com.echothree.model.data.payment.server.entity.PaymentMethodCreditCard; 033import com.echothree.util.common.exception.PersistenceDatabaseException; 034import com.echothree.util.common.exception.PersistenceDatabaseUpdateException; 035import com.echothree.util.common.exception.PersistenceNotNullException; 036import com.echothree.util.server.persistence.BaseFactory; 037import com.echothree.util.server.persistence.EntityIdGenerator; 038import com.echothree.util.server.persistence.EntityPermission; 039import com.echothree.util.server.persistence.PersistenceDebugFlags; 040import com.echothree.util.server.persistence.Session; 041import com.echothree.util.server.persistence.ThreadSession; 042import java.sql.PreparedStatement; 043import java.sql.ResultSet; 044import java.sql.SQLException; 045import java.sql.Types; 046import java.io.ByteArrayInputStream; 047import java.io.StringReader; 048import java.util.ArrayList; 049import java.util.Collection; 050import java.util.HashSet; 051import java.util.List; 052import java.util.Map; 053import java.util.Set; 054import org.apache.commons.logging.Log; 055import org.apache.commons.logging.LogFactory; 056 057public class PaymentMethodCreditCardFactory 058 implements BaseFactory<PaymentMethodCreditCardPK, PaymentMethodCreditCard> { 059 060 //final private static Log log = LogFactory.getLog(PaymentMethodCreditCardFactory.class); 061 062 final private static String SQL_SELECT_READ_ONLY = "SELECT pmcc_paymentmethodcreditcardid, pmcc_pm_paymentmethodid, pmcc_requestnameoncard, pmcc_requirenameoncard, pmcc_checkcardnumber, pmcc_requestexpirationdate, pmcc_requireexpirationdate, pmcc_checkexpirationdate, pmcc_requestsecuritycode, pmcc_requiresecuritycode, pmcc_cardnumbervalidationpattern, pmcc_securitycodevalidationpattern, pmcc_retaincreditcard, pmcc_retainsecuritycode, pmcc_requestbilling, pmcc_requirebilling, pmcc_requestissuer, pmcc_requireissuer, pmcc_fromtime, pmcc_thrutime FROM paymentmethodcreditcards WHERE pmcc_paymentmethodcreditcardid = ?"; 063 final private static String SQL_SELECT_READ_WRITE = "SELECT pmcc_paymentmethodcreditcardid, pmcc_pm_paymentmethodid, pmcc_requestnameoncard, pmcc_requirenameoncard, pmcc_checkcardnumber, pmcc_requestexpirationdate, pmcc_requireexpirationdate, pmcc_checkexpirationdate, pmcc_requestsecuritycode, pmcc_requiresecuritycode, pmcc_cardnumbervalidationpattern, pmcc_securitycodevalidationpattern, pmcc_retaincreditcard, pmcc_retainsecuritycode, pmcc_requestbilling, pmcc_requirebilling, pmcc_requestissuer, pmcc_requireissuer, pmcc_fromtime, pmcc_thrutime FROM paymentmethodcreditcards WHERE pmcc_paymentmethodcreditcardid = ? FOR UPDATE"; 064 final private static String SQL_INSERT = "INSERT INTO paymentmethodcreditcards (pmcc_paymentmethodcreditcardid, pmcc_pm_paymentmethodid, pmcc_requestnameoncard, pmcc_requirenameoncard, pmcc_checkcardnumber, pmcc_requestexpirationdate, pmcc_requireexpirationdate, pmcc_checkexpirationdate, pmcc_requestsecuritycode, pmcc_requiresecuritycode, pmcc_cardnumbervalidationpattern, pmcc_securitycodevalidationpattern, pmcc_retaincreditcard, pmcc_retainsecuritycode, pmcc_requestbilling, pmcc_requirebilling, pmcc_requestissuer, pmcc_requireissuer, pmcc_fromtime, pmcc_thrutime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"; 065 final private static String SQL_UPDATE = "UPDATE paymentmethodcreditcards SET pmcc_pm_paymentmethodid = ?, pmcc_requestnameoncard = ?, pmcc_requirenameoncard = ?, pmcc_checkcardnumber = ?, pmcc_requestexpirationdate = ?, pmcc_requireexpirationdate = ?, pmcc_checkexpirationdate = ?, pmcc_requestsecuritycode = ?, pmcc_requiresecuritycode = ?, pmcc_cardnumbervalidationpattern = ?, pmcc_securitycodevalidationpattern = ?, pmcc_retaincreditcard = ?, pmcc_retainsecuritycode = ?, pmcc_requestbilling = ?, pmcc_requirebilling = ?, pmcc_requestissuer = ?, pmcc_requireissuer = ?, pmcc_fromtime = ?, pmcc_thrutime = ? WHERE pmcc_paymentmethodcreditcardid = ?"; 066 final private static String SQL_DELETE = "DELETE FROM paymentmethodcreditcards WHERE pmcc_paymentmethodcreditcardid = ?"; 067 final private static String SQL_VALID = "SELECT COUNT(*) FROM paymentmethodcreditcards WHERE pmcc_paymentmethodcreditcardid = ?"; 068 069 final private static String PK_COLUMN = "pmcc_paymentmethodcreditcardid"; 070 final private static String ALL_COLUMNS = "pmcc_paymentmethodcreditcardid, pmcc_pm_paymentmethodid, pmcc_requestnameoncard, pmcc_requirenameoncard, pmcc_checkcardnumber, pmcc_requestexpirationdate, pmcc_requireexpirationdate, pmcc_checkexpirationdate, pmcc_requestsecuritycode, pmcc_requiresecuritycode, pmcc_cardnumbervalidationpattern, pmcc_securitycodevalidationpattern, pmcc_retaincreditcard, pmcc_retainsecuritycode, pmcc_requestbilling, pmcc_requirebilling, pmcc_requestissuer, pmcc_requireissuer, pmcc_fromtime, pmcc_thrutime"; 071 final public static String TABLE_NAME = "paymentmethodcreditcards"; 072 073 final public static String PMCC_PAYMENTMETHODCREDITCARDID = "pmcc_paymentmethodcreditcardid"; 074 final public static String PMCC_PM_PAYMENTMETHODID = "pmcc_pm_paymentmethodid"; 075 final public static String PMCC_REQUESTNAMEONCARD = "pmcc_requestnameoncard"; 076 final public static String PMCC_REQUIRENAMEONCARD = "pmcc_requirenameoncard"; 077 final public static String PMCC_CHECKCARDNUMBER = "pmcc_checkcardnumber"; 078 final public static String PMCC_REQUESTEXPIRATIONDATE = "pmcc_requestexpirationdate"; 079 final public static String PMCC_REQUIREEXPIRATIONDATE = "pmcc_requireexpirationdate"; 080 final public static String PMCC_CHECKEXPIRATIONDATE = "pmcc_checkexpirationdate"; 081 final public static String PMCC_REQUESTSECURITYCODE = "pmcc_requestsecuritycode"; 082 final public static String PMCC_REQUIRESECURITYCODE = "pmcc_requiresecuritycode"; 083 final public static String PMCC_CARDNUMBERVALIDATIONPATTERN = "pmcc_cardnumbervalidationpattern"; 084 final public static String PMCC_SECURITYCODEVALIDATIONPATTERN = "pmcc_securitycodevalidationpattern"; 085 final public static String PMCC_RETAINCREDITCARD = "pmcc_retaincreditcard"; 086 final public static String PMCC_RETAINSECURITYCODE = "pmcc_retainsecuritycode"; 087 final public static String PMCC_REQUESTBILLING = "pmcc_requestbilling"; 088 final public static String PMCC_REQUIREBILLING = "pmcc_requirebilling"; 089 final public static String PMCC_REQUESTISSUER = "pmcc_requestissuer"; 090 final public static String PMCC_REQUIREISSUER = "pmcc_requireissuer"; 091 final public static String PMCC_FROMTIME = "pmcc_fromtime"; 092 final public static String PMCC_THRUTIME = "pmcc_thrutime"; 093 094 final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(PaymentMethodCreditCardConstants.COMPONENT_VENDOR_NAME, PaymentMethodCreditCardConstants.ENTITY_TYPE_NAME); 095 096 /** Creates a new instance of PaymentMethodCreditCardFactory */ 097 private PaymentMethodCreditCardFactory() { 098 super(); 099 } 100 101 private static class PaymentMethodCreditCardFactoryHolder { 102 static PaymentMethodCreditCardFactory instance = new PaymentMethodCreditCardFactory(); 103 } 104 105 public static PaymentMethodCreditCardFactory getInstance() { 106 return PaymentMethodCreditCardFactoryHolder.instance; 107 } 108 109 @Override 110 public String getPKColumn() { 111 return PK_COLUMN; 112 } 113 114 @Override 115 public String getAllColumns() { 116 return ALL_COLUMNS; 117 } 118 119 @Override 120 public String getTableName() { 121 return TABLE_NAME; 122 } 123 124 @Override 125 public String getComponentVendorName() { 126 return PaymentMethodCreditCardConstants.COMPONENT_VENDOR_NAME; 127 } 128 129 @Override 130 public String getEntityTypeName() { 131 return PaymentMethodCreditCardConstants.ENTITY_TYPE_NAME; 132 } 133 134 public PreparedStatement prepareStatement(String query) { 135 return ThreadSession.currentSession().prepareStatement(PaymentMethodCreditCardFactory.class, query); 136 } 137 138 public PaymentMethodCreditCardPK getNextPK() { 139 return new PaymentMethodCreditCardPK(entityIdGenerator.getNextEntityId()); 140 } 141 142 public Set<PaymentMethodCreditCardPK> getPKsFromResultSetAsSet(ResultSet rs) 143 throws PersistenceDatabaseException { 144 Set<PaymentMethodCreditCardPK> _result = new HashSet<>(); 145 146 try { 147 while(rs.next()) { 148 _result.add(getPKFromResultSet(rs)); 149 } 150 } catch (SQLException se) { 151 throw new PersistenceDatabaseException(se); 152 } 153 154 return _result; 155 } 156 157 public java.util.List<PaymentMethodCreditCardPK> getPKsFromResultSetAsList(ResultSet rs) 158 throws PersistenceDatabaseException { 159 java.util.List<PaymentMethodCreditCardPK> _result = new ArrayList<>(); 160 161 try { 162 while(rs.next()) { 163 _result.add(getPKFromResultSet(rs)); 164 } 165 } catch (SQLException se) { 166 throw new PersistenceDatabaseException(se); 167 } 168 169 return _result; 170 } 171 172 public PaymentMethodCreditCardPK getPKFromResultSet(ResultSet rs) 173 throws PersistenceDatabaseException { 174 PaymentMethodCreditCardPK _result; 175 176 try { 177 long pmcc_paymentmethodcreditcardid = rs.getLong(PMCC_PAYMENTMETHODCREDITCARDID); 178 Long _entityId = rs.wasNull() ? null : pmcc_paymentmethodcreditcardid; 179 180 _result = new PaymentMethodCreditCardPK(_entityId); 181 } catch (SQLException se) { 182 throw new PersistenceDatabaseException(se); 183 } 184 185 return _result; 186 } 187 188 public java.util.List<PaymentMethodCreditCardValue> getValuesFromPKs(Session session, Collection<PaymentMethodCreditCardPK> pks) 189 throws PersistenceDatabaseException { 190 java.util.List<PaymentMethodCreditCardValue> _values = new ArrayList<>(pks.size()); 191 192 for(PaymentMethodCreditCardPK _pk: pks) { 193 _values.add(getValueFromPK(session, _pk)); 194 } 195 196 return _values; 197 } 198 199 public PaymentMethodCreditCardValue getValueFromPK(Session session, PaymentMethodCreditCardPK pk) 200 throws PersistenceDatabaseException { 201 PaymentMethodCreditCardValue _value; 202 203 // See if we already have the entity in the session cache 204 PaymentMethodCreditCard _entity = (PaymentMethodCreditCard)session.getEntity(pk); 205 if(_entity == null) 206 _value = getEntityFromPK(session, EntityPermission.READ_ONLY, pk).getPaymentMethodCreditCardValue(); 207 else 208 _value = _entity.getPaymentMethodCreditCardValue(); 209 210 return _value; 211 } 212 213 public java.util.List<PaymentMethodCreditCardValue> getValuesFromResultSet(Session session, ResultSet rs) 214 throws PersistenceDatabaseException { 215 java.util.List<PaymentMethodCreditCardValue> _result = new ArrayList<>(); 216 217 try { 218 while(rs.next()) { 219 _result.add(getValueFromResultSet(session, rs)); 220 } 221 } catch (SQLException se) { 222 throw new PersistenceDatabaseException(se); 223 } 224 225 return _result; 226 } 227 228 public PaymentMethodCreditCardValue getValueFromResultSet(Session session, ResultSet rs) 229 throws PersistenceDatabaseException { 230 PaymentMethodCreditCardValue _value; 231 232 try { 233 Long pmcc_paymentmethodcreditcardid = rs.getLong(PMCC_PAYMENTMETHODCREDITCARDID); 234 PaymentMethodCreditCardPK _pk = new PaymentMethodCreditCardPK(pmcc_paymentmethodcreditcardid); 235 236 // See if we already have the entity in the session cache 237 PaymentMethodCreditCard _entity = (PaymentMethodCreditCard)session.getEntity(_pk); 238 239 if(_entity == null) { 240 Long pmcc_pm_paymentmethodid = rs.getLong(PMCC_PM_PAYMENTMETHODID); 241 if(rs.wasNull()) 242 pmcc_pm_paymentmethodid = null; 243 244 Boolean pmcc_requestnameoncard = rs.getInt(PMCC_REQUESTNAMEONCARD) == 1; 245 if(rs.wasNull()) 246 pmcc_requestnameoncard = null; 247 248 Boolean pmcc_requirenameoncard = rs.getInt(PMCC_REQUIRENAMEONCARD) == 1; 249 if(rs.wasNull()) 250 pmcc_requirenameoncard = null; 251 252 Boolean pmcc_checkcardnumber = rs.getInt(PMCC_CHECKCARDNUMBER) == 1; 253 if(rs.wasNull()) 254 pmcc_checkcardnumber = null; 255 256 Boolean pmcc_requestexpirationdate = rs.getInt(PMCC_REQUESTEXPIRATIONDATE) == 1; 257 if(rs.wasNull()) 258 pmcc_requestexpirationdate = null; 259 260 Boolean pmcc_requireexpirationdate = rs.getInt(PMCC_REQUIREEXPIRATIONDATE) == 1; 261 if(rs.wasNull()) 262 pmcc_requireexpirationdate = null; 263 264 Boolean pmcc_checkexpirationdate = rs.getInt(PMCC_CHECKEXPIRATIONDATE) == 1; 265 if(rs.wasNull()) 266 pmcc_checkexpirationdate = null; 267 268 Boolean pmcc_requestsecuritycode = rs.getInt(PMCC_REQUESTSECURITYCODE) == 1; 269 if(rs.wasNull()) 270 pmcc_requestsecuritycode = null; 271 272 Boolean pmcc_requiresecuritycode = rs.getInt(PMCC_REQUIRESECURITYCODE) == 1; 273 if(rs.wasNull()) 274 pmcc_requiresecuritycode = null; 275 276 String pmcc_cardnumbervalidationpattern = rs.getString(PMCC_CARDNUMBERVALIDATIONPATTERN); 277 if(rs.wasNull()) 278 pmcc_cardnumbervalidationpattern = null; 279 280 String pmcc_securitycodevalidationpattern = rs.getString(PMCC_SECURITYCODEVALIDATIONPATTERN); 281 if(rs.wasNull()) 282 pmcc_securitycodevalidationpattern = null; 283 284 Boolean pmcc_retaincreditcard = rs.getInt(PMCC_RETAINCREDITCARD) == 1; 285 if(rs.wasNull()) 286 pmcc_retaincreditcard = null; 287 288 Boolean pmcc_retainsecuritycode = rs.getInt(PMCC_RETAINSECURITYCODE) == 1; 289 if(rs.wasNull()) 290 pmcc_retainsecuritycode = null; 291 292 Boolean pmcc_requestbilling = rs.getInt(PMCC_REQUESTBILLING) == 1; 293 if(rs.wasNull()) 294 pmcc_requestbilling = null; 295 296 Boolean pmcc_requirebilling = rs.getInt(PMCC_REQUIREBILLING) == 1; 297 if(rs.wasNull()) 298 pmcc_requirebilling = null; 299 300 Boolean pmcc_requestissuer = rs.getInt(PMCC_REQUESTISSUER) == 1; 301 if(rs.wasNull()) 302 pmcc_requestissuer = null; 303 304 Boolean pmcc_requireissuer = rs.getInt(PMCC_REQUIREISSUER) == 1; 305 if(rs.wasNull()) 306 pmcc_requireissuer = null; 307 308 Long pmcc_fromtime = rs.getLong(PMCC_FROMTIME); 309 if(rs.wasNull()) 310 pmcc_fromtime = null; 311 312 Long pmcc_thrutime = rs.getLong(PMCC_THRUTIME); 313 if(rs.wasNull()) 314 pmcc_thrutime = null; 315 316 _value = new PaymentMethodCreditCardValue(_pk, new PaymentMethodPK(pmcc_pm_paymentmethodid), pmcc_requestnameoncard, pmcc_requirenameoncard, pmcc_checkcardnumber, pmcc_requestexpirationdate, pmcc_requireexpirationdate, pmcc_checkexpirationdate, pmcc_requestsecuritycode, pmcc_requiresecuritycode, pmcc_cardnumbervalidationpattern, pmcc_securitycodevalidationpattern, pmcc_retaincreditcard, pmcc_retainsecuritycode, pmcc_requestbilling, pmcc_requirebilling, pmcc_requestissuer, pmcc_requireissuer, pmcc_fromtime, pmcc_thrutime); 317 } else 318 _value = _entity.getPaymentMethodCreditCardValue(); 319 } catch (SQLException se) { 320 throw new PersistenceDatabaseException(se); 321 } 322 323 return _value; 324 } 325 326 public java.util.List<PaymentMethodCreditCard> getEntitiesFromPKs(EntityPermission entityPermission, Collection<PaymentMethodCreditCardPK> pks) 327 throws PersistenceDatabaseException { 328 return getEntitiesFromPKs(ThreadSession.currentSession(), entityPermission, pks); 329 } 330 331 public java.util.List<PaymentMethodCreditCard> getEntitiesFromPKs(Session session, EntityPermission entityPermission, Collection<PaymentMethodCreditCardPK> pks) 332 throws PersistenceDatabaseException { 333 java.util.List<PaymentMethodCreditCard> _entities = new ArrayList<>(pks.size()); 334 335 for(PaymentMethodCreditCardPK _pk: pks) { 336 _entities.add(getEntityFromPK(session, entityPermission, _pk)); 337 } 338 339 return _entities; 340 } 341 342 public PaymentMethodCreditCard getEntityFromValue(EntityPermission entityPermission, PaymentMethodCreditCardValue value) { 343 return getEntityFromPK(ThreadSession.currentSession(), entityPermission, value.getPrimaryKey()); 344 } 345 346 public PaymentMethodCreditCard getEntityFromValue(Session session, EntityPermission entityPermission, PaymentMethodCreditCardValue value) { 347 return getEntityFromPK(session, entityPermission, value.getPrimaryKey()); 348 } 349 350 public PaymentMethodCreditCard getEntityFromPK(EntityPermission entityPermission, PaymentMethodCreditCardPK pk) 351 throws PersistenceDatabaseException { 352 return getEntityFromPK(ThreadSession.currentSession(), entityPermission, pk); 353 } 354 355 public PaymentMethodCreditCard getEntityFromCache(Session session, PaymentMethodCreditCardPK pk) { 356 PaymentMethodCreditCardValue _value = (PaymentMethodCreditCardValue)session.getValueCache().get(pk); 357 358 return _value == null ? null : new PaymentMethodCreditCard(_value, EntityPermission.READ_ONLY); 359 } 360 361 public PaymentMethodCreditCard getEntityFromPK(Session session, EntityPermission entityPermission, PaymentMethodCreditCardPK pk) 362 throws PersistenceDatabaseException { 363 PaymentMethodCreditCard _entity; 364 365 // See if we already have the entity in the session cache 366 _entity = (PaymentMethodCreditCard)session.getEntity(pk); 367 if(_entity != null) { 368 // If the requested permission is READ_WRITE, and the cached permission is 369 // READ_ONLY, then pretend that the cached object wasn't found, and create 370 // a new entity that is READ_WRITE. 371 if(entityPermission.equals(EntityPermission.READ_WRITE)) { 372 if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY)) 373 _entity = null; 374 } 375 } 376 377 if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) { 378 _entity = getEntityFromCache(session, pk); 379 } 380 381 if(_entity == null) { 382 PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE); 383 long _entityId = pk.getEntityId(); 384 ResultSet _rs = null; 385 386 try { 387 _ps.setLong(1, _entityId); 388 _rs = _ps.executeQuery(); 389 if(_rs.next()) { 390 _entity = getEntityFromResultSet(session, entityPermission, _rs); 391 } 392 } catch (SQLException se) { 393 throw new PersistenceDatabaseException(se); 394 } finally { 395 if(_rs != null) { 396 try { 397 _rs.close(); 398 } catch (SQLException se) { 399 // do nothing 400 } 401 } 402 } 403 } 404 405 return _entity; 406 } 407 408 public Set<PaymentMethodCreditCardPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params) 409 throws PersistenceDatabaseException { 410 Set<PaymentMethodCreditCardPK> _pks; 411 ResultSet _rs = null; 412 413 try { 414 if(params.length != 0) { 415 Session.setQueryParams(ps, params); 416 } 417 418 _rs = ps.executeQuery(); 419 _pks = getPKsFromResultSetAsSet(_rs); 420 _rs.close(); 421 } catch (SQLException se) { 422 throw new PersistenceDatabaseException(se); 423 } finally { 424 if(_rs != null) { 425 try { 426 _rs.close(); 427 } catch (SQLException se) { 428 // do nothing 429 } 430 } 431 } 432 433 return _pks; 434 } 435 436 public java.util.List<PaymentMethodCreditCardPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params) 437 throws PersistenceDatabaseException { 438 java.util.List<PaymentMethodCreditCardPK> _pks; 439 ResultSet _rs = null; 440 441 try { 442 if(params.length != 0) { 443 Session.setQueryParams(ps, params); 444 } 445 446 _rs = ps.executeQuery(); 447 _pks = getPKsFromResultSetAsList(_rs); 448 _rs.close(); 449 } catch (SQLException se) { 450 throw new PersistenceDatabaseException(se); 451 } finally { 452 if(_rs != null) { 453 try { 454 _rs.close(); 455 } catch (SQLException se) { 456 // do nothing 457 } 458 } 459 } 460 461 return _pks; 462 } 463 464 public PaymentMethodCreditCardPK getPKFromQuery(PreparedStatement ps, final Object... params) 465 throws PersistenceDatabaseException { 466 PaymentMethodCreditCardPK _pk = null; 467 ResultSet _rs = null; 468 469 try { 470 if(params.length != 0) { 471 Session.setQueryParams(ps, params); 472 } 473 474 _rs = ps.executeQuery(); 475 if(_rs.next()) { 476 _pk = getPKFromResultSet(_rs); 477 } 478 _rs.close(); 479 } catch (SQLException se) { 480 throw new PersistenceDatabaseException(se); 481 } finally { 482 if(_rs != null) { 483 try { 484 _rs.close(); 485 } catch (SQLException se) { 486 // do nothing 487 } 488 } 489 } 490 491 return _pk; 492 } 493 494 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params) 495 throws PersistenceDatabaseException { 496 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 497 498 return getEntitiesFromQuery(session, entityPermission, ps, params); 499 } 500 501 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params) 502 throws PersistenceDatabaseException { 503 Session session = ThreadSession.currentSession(); 504 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 505 506 return getEntitiesFromQuery(session, entityPermission, ps, params); 507 } 508 509 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap) 510 throws PersistenceDatabaseException { 511 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 512 513 return getEntitiesFromQuery(session, entityPermission, ps); 514 } 515 516 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap) 517 throws PersistenceDatabaseException { 518 Session session = ThreadSession.currentSession(); 519 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 520 521 return getEntitiesFromQuery(session, entityPermission, ps); 522 } 523 524 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps) 525 throws PersistenceDatabaseException { 526 return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps); 527 } 528 529 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params) 530 throws PersistenceDatabaseException { 531 return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps, params); 532 } 533 534 public java.util.List<PaymentMethodCreditCard> getEntitiesFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params) 535 throws PersistenceDatabaseException { 536 java.util.List<PaymentMethodCreditCard> _entities; 537 ResultSet _rs = null; 538 539 try { 540 if(params.length != 0) { 541 Session.setQueryParams(ps, params); 542 } 543 544 _rs = ps.executeQuery(); 545 _entities = getEntitiesFromResultSet(session, entityPermission, _rs); 546 _rs.close(); 547 } catch (SQLException se) { 548 throw new PersistenceDatabaseException(se); 549 } finally { 550 if(_rs != null) { 551 try { 552 _rs.close(); 553 } catch (SQLException se) { 554 // do nothing 555 } 556 } 557 } 558 559 return _entities; 560 } 561 562 public PaymentMethodCreditCard getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params) 563 throws PersistenceDatabaseException { 564 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 565 566 return getEntityFromQuery(session, entityPermission, ps, params); 567 } 568 569 public PaymentMethodCreditCard getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params) 570 throws PersistenceDatabaseException { 571 Session session = ThreadSession.currentSession(); 572 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 573 574 return getEntityFromQuery(session, entityPermission, ps, params); 575 } 576 577 public PaymentMethodCreditCard getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap) 578 throws PersistenceDatabaseException { 579 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 580 581 return getEntityFromQuery(session, entityPermission, ps); 582 } 583 584 public PaymentMethodCreditCard getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap) 585 throws PersistenceDatabaseException { 586 Session session = ThreadSession.currentSession(); 587 PreparedStatement ps = session.prepareStatement(PaymentMethodCreditCardFactory.class, queryMap.get(entityPermission)); 588 589 return getEntityFromQuery(session, entityPermission, ps); 590 } 591 592 public PaymentMethodCreditCard getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps) 593 throws PersistenceDatabaseException { 594 return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps); 595 } 596 597 public PaymentMethodCreditCard getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params) 598 throws PersistenceDatabaseException { 599 return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps, params); 600 } 601 602 public PaymentMethodCreditCard getEntityFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params) 603 throws PersistenceDatabaseException { 604 PaymentMethodCreditCard _entity = null; 605 ResultSet _rs = null; 606 607 try { 608 if(params.length != 0) { 609 Session.setQueryParams(ps, params); 610 } 611 612 _rs = ps.executeQuery(); 613 if(_rs.next()) { 614 _entity = getEntityFromResultSet(session, entityPermission, _rs); 615 } 616 _rs.close(); 617 } catch (SQLException se) { 618 throw new PersistenceDatabaseException(se); 619 } finally { 620 if(_rs != null) { 621 try { 622 _rs.close(); 623 } catch (SQLException se) { 624 // do nothing 625 } 626 } 627 } 628 629 return _entity; 630 } 631 632 public java.util.List<PaymentMethodCreditCard> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs) 633 throws PersistenceDatabaseException { 634 return getEntitiesFromResultSet(ThreadSession.currentSession(), entityPermission, rs); 635 } 636 637 public java.util.List<PaymentMethodCreditCard> getEntitiesFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs) 638 throws PersistenceDatabaseException { 639 java.util.List<PaymentMethodCreditCard> _result = new ArrayList<>(); 640 641 try { 642 while(rs.next()) { 643 _result.add(getEntityFromResultSet(session, entityPermission, rs)); 644 } 645 } catch (SQLException se) { 646 throw new PersistenceDatabaseException(se); 647 } 648 649 return _result; 650 } 651 652 public PaymentMethodCreditCard getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs) 653 throws PersistenceDatabaseException { 654 return getEntityFromResultSet(ThreadSession.currentSession(), entityPermission, rs); 655 } 656 657 public PaymentMethodCreditCard getEntityFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs) 658 throws PersistenceDatabaseException { 659 PaymentMethodCreditCard _entity; 660 661 try { 662 Long pmcc_paymentmethodcreditcardid = rs.getLong(PMCC_PAYMENTMETHODCREDITCARDID); 663 PaymentMethodCreditCardPK _pk = new PaymentMethodCreditCardPK(pmcc_paymentmethodcreditcardid); 664 665 // See if we already have the entity in the session cache 666 _entity = (PaymentMethodCreditCard)session.getEntity(_pk); 667 if(_entity != null) { 668 // If the requested permission is READ_WRITE, and the cached permission is 669 // READ_ONLY, then pretend that the cached object wasn't found, and create 670 // a new entity that is READ_WRITE. 671 if(entityPermission.equals(EntityPermission.READ_WRITE)) { 672 if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY)) 673 _entity = null; 674 } 675 } 676 boolean foundInSessionCache = _entity != null; 677 678 if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) { 679 _entity = getEntityFromCache(session, _pk); 680 } 681 682 if(_entity == null) { 683 Long pmcc_pm_paymentmethodid = rs.getLong(PMCC_PM_PAYMENTMETHODID); 684 if(rs.wasNull()) 685 pmcc_pm_paymentmethodid = null; 686 687 Boolean pmcc_requestnameoncard = rs.getInt(PMCC_REQUESTNAMEONCARD) == 1; 688 if(rs.wasNull()) 689 pmcc_requestnameoncard = null; 690 691 Boolean pmcc_requirenameoncard = rs.getInt(PMCC_REQUIRENAMEONCARD) == 1; 692 if(rs.wasNull()) 693 pmcc_requirenameoncard = null; 694 695 Boolean pmcc_checkcardnumber = rs.getInt(PMCC_CHECKCARDNUMBER) == 1; 696 if(rs.wasNull()) 697 pmcc_checkcardnumber = null; 698 699 Boolean pmcc_requestexpirationdate = rs.getInt(PMCC_REQUESTEXPIRATIONDATE) == 1; 700 if(rs.wasNull()) 701 pmcc_requestexpirationdate = null; 702 703 Boolean pmcc_requireexpirationdate = rs.getInt(PMCC_REQUIREEXPIRATIONDATE) == 1; 704 if(rs.wasNull()) 705 pmcc_requireexpirationdate = null; 706 707 Boolean pmcc_checkexpirationdate = rs.getInt(PMCC_CHECKEXPIRATIONDATE) == 1; 708 if(rs.wasNull()) 709 pmcc_checkexpirationdate = null; 710 711 Boolean pmcc_requestsecuritycode = rs.getInt(PMCC_REQUESTSECURITYCODE) == 1; 712 if(rs.wasNull()) 713 pmcc_requestsecuritycode = null; 714 715 Boolean pmcc_requiresecuritycode = rs.getInt(PMCC_REQUIRESECURITYCODE) == 1; 716 if(rs.wasNull()) 717 pmcc_requiresecuritycode = null; 718 719 String pmcc_cardnumbervalidationpattern = rs.getString(PMCC_CARDNUMBERVALIDATIONPATTERN); 720 if(rs.wasNull()) 721 pmcc_cardnumbervalidationpattern = null; 722 723 String pmcc_securitycodevalidationpattern = rs.getString(PMCC_SECURITYCODEVALIDATIONPATTERN); 724 if(rs.wasNull()) 725 pmcc_securitycodevalidationpattern = null; 726 727 Boolean pmcc_retaincreditcard = rs.getInt(PMCC_RETAINCREDITCARD) == 1; 728 if(rs.wasNull()) 729 pmcc_retaincreditcard = null; 730 731 Boolean pmcc_retainsecuritycode = rs.getInt(PMCC_RETAINSECURITYCODE) == 1; 732 if(rs.wasNull()) 733 pmcc_retainsecuritycode = null; 734 735 Boolean pmcc_requestbilling = rs.getInt(PMCC_REQUESTBILLING) == 1; 736 if(rs.wasNull()) 737 pmcc_requestbilling = null; 738 739 Boolean pmcc_requirebilling = rs.getInt(PMCC_REQUIREBILLING) == 1; 740 if(rs.wasNull()) 741 pmcc_requirebilling = null; 742 743 Boolean pmcc_requestissuer = rs.getInt(PMCC_REQUESTISSUER) == 1; 744 if(rs.wasNull()) 745 pmcc_requestissuer = null; 746 747 Boolean pmcc_requireissuer = rs.getInt(PMCC_REQUIREISSUER) == 1; 748 if(rs.wasNull()) 749 pmcc_requireissuer = null; 750 751 Long pmcc_fromtime = rs.getLong(PMCC_FROMTIME); 752 if(rs.wasNull()) 753 pmcc_fromtime = null; 754 755 Long pmcc_thrutime = rs.getLong(PMCC_THRUTIME); 756 if(rs.wasNull()) 757 pmcc_thrutime = null; 758 759 PaymentMethodCreditCardValue _value = new PaymentMethodCreditCardValue(_pk, pmcc_pm_paymentmethodid == null? null: new PaymentMethodPK(pmcc_pm_paymentmethodid), pmcc_requestnameoncard, pmcc_requirenameoncard, pmcc_checkcardnumber, pmcc_requestexpirationdate, pmcc_requireexpirationdate, pmcc_checkexpirationdate, pmcc_requestsecuritycode, pmcc_requiresecuritycode, pmcc_cardnumbervalidationpattern, pmcc_securitycodevalidationpattern, pmcc_retaincreditcard, pmcc_retainsecuritycode, pmcc_requestbilling, pmcc_requirebilling, pmcc_requestissuer, pmcc_requireissuer, pmcc_fromtime, pmcc_thrutime); 760 _entity = new PaymentMethodCreditCard(_value, entityPermission); 761 } 762 763 if(!foundInSessionCache) { 764 if(entityPermission.equals(EntityPermission.READ_ONLY)) { 765 session.putReadOnlyEntity(_pk, _entity); 766 session.getValueCache().put(_entity.getPaymentMethodCreditCardValue()); 767 } else { 768 session.putReadWriteEntity(_pk, _entity); 769 } 770 } 771 } catch (SQLException se) { 772 throw new PersistenceDatabaseException(se); 773 } 774 775 return _entity; 776 } 777 778 public PaymentMethodCreditCard create(Session session, PaymentMethod paymentMethod, Boolean requestNameOnCard, Boolean requireNameOnCard, Boolean checkCardNumber, Boolean requestExpirationDate, Boolean requireExpirationDate, Boolean checkExpirationDate, Boolean requestSecurityCode, Boolean requireSecurityCode, String cardNumberValidationPattern, String securityCodeValidationPattern, Boolean retainCreditCard, Boolean retainSecurityCode, Boolean requestBilling, Boolean requireBilling, Boolean requestIssuer, Boolean requireIssuer, Long fromTime, Long thruTime) 779 throws PersistenceDatabaseException, PersistenceNotNullException { 780 return create(session, paymentMethod == null ? null : paymentMethod.getPrimaryKey(), requestNameOnCard, requireNameOnCard, checkCardNumber, requestExpirationDate, requireExpirationDate, checkExpirationDate, requestSecurityCode, requireSecurityCode, cardNumberValidationPattern, securityCodeValidationPattern, retainCreditCard, retainSecurityCode, requestBilling, requireBilling, requestIssuer, requireIssuer, fromTime, thruTime); 781 } 782 783 public PaymentMethodCreditCard create(PaymentMethod paymentMethod, Boolean requestNameOnCard, Boolean requireNameOnCard, Boolean checkCardNumber, Boolean requestExpirationDate, Boolean requireExpirationDate, Boolean checkExpirationDate, Boolean requestSecurityCode, Boolean requireSecurityCode, String cardNumberValidationPattern, String securityCodeValidationPattern, Boolean retainCreditCard, Boolean retainSecurityCode, Boolean requestBilling, Boolean requireBilling, Boolean requestIssuer, Boolean requireIssuer, Long fromTime, Long thruTime) 784 throws PersistenceDatabaseException, PersistenceNotNullException { 785 return create(ThreadSession.currentSession(), paymentMethod == null ? null : paymentMethod.getPrimaryKey(), requestNameOnCard, requireNameOnCard, checkCardNumber, requestExpirationDate, requireExpirationDate, checkExpirationDate, requestSecurityCode, requireSecurityCode, cardNumberValidationPattern, securityCodeValidationPattern, retainCreditCard, retainSecurityCode, requestBilling, requireBilling, requestIssuer, requireIssuer, fromTime, thruTime); 786 } 787 788 private void bindForCreate(PreparedStatement _ps, PaymentMethodCreditCardValue _value) 789 throws SQLException { 790 _ps.setLong(1, _value.getEntityId()); 791 792 PaymentMethodPK pmcc_pm_paymentmethodid = _value.getPaymentMethodPK(); 793 if(pmcc_pm_paymentmethodid == null) 794 _ps.setNull(2, Types.BIGINT); 795 else 796 _ps.setLong(2, pmcc_pm_paymentmethodid.getEntityId()); 797 798 Boolean pmcc_requestnameoncard = _value.getRequestNameOnCard(); 799 if(pmcc_requestnameoncard == null) 800 _ps.setNull(3, Types.BIT); 801 else 802 _ps.setInt(3, pmcc_requestnameoncard? 1: 0); 803 804 Boolean pmcc_requirenameoncard = _value.getRequireNameOnCard(); 805 if(pmcc_requirenameoncard == null) 806 _ps.setNull(4, Types.BIT); 807 else 808 _ps.setInt(4, pmcc_requirenameoncard? 1: 0); 809 810 Boolean pmcc_checkcardnumber = _value.getCheckCardNumber(); 811 if(pmcc_checkcardnumber == null) 812 _ps.setNull(5, Types.BIT); 813 else 814 _ps.setInt(5, pmcc_checkcardnumber? 1: 0); 815 816 Boolean pmcc_requestexpirationdate = _value.getRequestExpirationDate(); 817 if(pmcc_requestexpirationdate == null) 818 _ps.setNull(6, Types.BIT); 819 else 820 _ps.setInt(6, pmcc_requestexpirationdate? 1: 0); 821 822 Boolean pmcc_requireexpirationdate = _value.getRequireExpirationDate(); 823 if(pmcc_requireexpirationdate == null) 824 _ps.setNull(7, Types.BIT); 825 else 826 _ps.setInt(7, pmcc_requireexpirationdate? 1: 0); 827 828 Boolean pmcc_checkexpirationdate = _value.getCheckExpirationDate(); 829 if(pmcc_checkexpirationdate == null) 830 _ps.setNull(8, Types.BIT); 831 else 832 _ps.setInt(8, pmcc_checkexpirationdate? 1: 0); 833 834 Boolean pmcc_requestsecuritycode = _value.getRequestSecurityCode(); 835 if(pmcc_requestsecuritycode == null) 836 _ps.setNull(9, Types.BIT); 837 else 838 _ps.setInt(9, pmcc_requestsecuritycode? 1: 0); 839 840 Boolean pmcc_requiresecuritycode = _value.getRequireSecurityCode(); 841 if(pmcc_requiresecuritycode == null) 842 _ps.setNull(10, Types.BIT); 843 else 844 _ps.setInt(10, pmcc_requiresecuritycode? 1: 0); 845 846 String pmcc_cardnumbervalidationpattern = _value.getCardNumberValidationPattern(); 847 if(pmcc_cardnumbervalidationpattern == null) 848 _ps.setNull(11, Types.VARCHAR); 849 else 850 _ps.setString(11, pmcc_cardnumbervalidationpattern); 851 852 String pmcc_securitycodevalidationpattern = _value.getSecurityCodeValidationPattern(); 853 if(pmcc_securitycodevalidationpattern == null) 854 _ps.setNull(12, Types.VARCHAR); 855 else 856 _ps.setString(12, pmcc_securitycodevalidationpattern); 857 858 Boolean pmcc_retaincreditcard = _value.getRetainCreditCard(); 859 if(pmcc_retaincreditcard == null) 860 _ps.setNull(13, Types.BIT); 861 else 862 _ps.setInt(13, pmcc_retaincreditcard? 1: 0); 863 864 Boolean pmcc_retainsecuritycode = _value.getRetainSecurityCode(); 865 if(pmcc_retainsecuritycode == null) 866 _ps.setNull(14, Types.BIT); 867 else 868 _ps.setInt(14, pmcc_retainsecuritycode? 1: 0); 869 870 Boolean pmcc_requestbilling = _value.getRequestBilling(); 871 if(pmcc_requestbilling == null) 872 _ps.setNull(15, Types.BIT); 873 else 874 _ps.setInt(15, pmcc_requestbilling? 1: 0); 875 876 Boolean pmcc_requirebilling = _value.getRequireBilling(); 877 if(pmcc_requirebilling == null) 878 _ps.setNull(16, Types.BIT); 879 else 880 _ps.setInt(16, pmcc_requirebilling? 1: 0); 881 882 Boolean pmcc_requestissuer = _value.getRequestIssuer(); 883 if(pmcc_requestissuer == null) 884 _ps.setNull(17, Types.BIT); 885 else 886 _ps.setInt(17, pmcc_requestissuer? 1: 0); 887 888 Boolean pmcc_requireissuer = _value.getRequireIssuer(); 889 if(pmcc_requireissuer == null) 890 _ps.setNull(18, Types.BIT); 891 else 892 _ps.setInt(18, pmcc_requireissuer? 1: 0); 893 894 Long pmcc_fromtime = _value.getFromTime(); 895 if(pmcc_fromtime == null) 896 _ps.setNull(19, Types.BIGINT); 897 else 898 _ps.setLong(19, pmcc_fromtime); 899 900 Long pmcc_thrutime = _value.getThruTime(); 901 if(pmcc_thrutime == null) 902 _ps.setNull(20, Types.BIGINT); 903 else 904 _ps.setLong(20, pmcc_thrutime); 905 906 } 907 908 public PaymentMethodCreditCard create(Session session, PaymentMethodPK paymentMethodPK, Boolean requestNameOnCard, Boolean requireNameOnCard, Boolean checkCardNumber, Boolean requestExpirationDate, Boolean requireExpirationDate, Boolean checkExpirationDate, Boolean requestSecurityCode, Boolean requireSecurityCode, String cardNumberValidationPattern, String securityCodeValidationPattern, Boolean retainCreditCard, Boolean retainSecurityCode, Boolean requestBilling, Boolean requireBilling, Boolean requestIssuer, Boolean requireIssuer, Long fromTime, Long thruTime) 909 throws PersistenceDatabaseException, PersistenceNotNullException { 910 PaymentMethodCreditCardPK _pk = getNextPK(); 911 PaymentMethodCreditCardValue _value = new PaymentMethodCreditCardValue(_pk, paymentMethodPK, requestNameOnCard, requireNameOnCard, checkCardNumber, requestExpirationDate, requireExpirationDate, checkExpirationDate, requestSecurityCode, requireSecurityCode, cardNumberValidationPattern, securityCodeValidationPattern, retainCreditCard, retainSecurityCode, requestBilling, requireBilling, requestIssuer, requireIssuer, fromTime, thruTime); 912 913 PreparedStatement _ps = session.prepareStatement(SQL_INSERT); 914 915 try { 916 bindForCreate(_ps, _value); 917 918 if(PersistenceDebugFlags.CheckEntityInsertRowCount) { 919 int _count = _ps.executeUpdate(); 920 921 if(_count != 1) { 922 throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count); 923 } 924 } else { 925 _ps.executeUpdate(); 926 } 927 928 session.getValueCache().put(_value); 929 } catch (SQLException se) { 930 throw new PersistenceDatabaseException(se); 931 } 932 933 PaymentMethodCreditCard _entity = new PaymentMethodCreditCard(_value, EntityPermission.READ_ONLY); 934 session.putReadOnlyEntity(_pk, _entity); 935 936 return _entity; 937 } 938 939 public PaymentMethodCreditCard create(PaymentMethodPK paymentMethodPK, Boolean requestNameOnCard, Boolean requireNameOnCard, Boolean checkCardNumber, Boolean requestExpirationDate, Boolean requireExpirationDate, Boolean checkExpirationDate, Boolean requestSecurityCode, Boolean requireSecurityCode, String cardNumberValidationPattern, String securityCodeValidationPattern, Boolean retainCreditCard, Boolean retainSecurityCode, Boolean requestBilling, Boolean requireBilling, Boolean requestIssuer, Boolean requireIssuer, Long fromTime, Long thruTime) 940 throws PersistenceDatabaseException, PersistenceNotNullException { 941 return create(ThreadSession.currentSession(), paymentMethodPK, requestNameOnCard, requireNameOnCard, checkCardNumber, requestExpirationDate, requireExpirationDate, checkExpirationDate, requestSecurityCode, requireSecurityCode, cardNumberValidationPattern, securityCodeValidationPattern, retainCreditCard, retainSecurityCode, requestBilling, requireBilling, requestIssuer, requireIssuer, fromTime, thruTime); 942 } 943 944 public void create(Session session, Collection<PaymentMethodCreditCardValue> _values) 945 throws PersistenceDatabaseException, PersistenceNotNullException { 946 int _size = _values.size(); 947 948 if(_size > 0) { 949 PreparedStatement _ps = session.prepareStatement(SQL_INSERT); 950 List<PaymentMethodCreditCardValue> _cacheValues = new ArrayList<>(_size); 951 952 try { 953 for(PaymentMethodCreditCardValue _value : _values) { 954 _value.setEntityId(entityIdGenerator.getNextEntityId()); 955 bindForCreate(_ps, _value); 956 957 _ps.addBatch(); 958 959 _cacheValues.add(_value); 960 } 961 962 if(PersistenceDebugFlags.CheckEntityInsertRowCount) { 963 int[] _counts = _ps.executeBatch(); 964 965 for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) { 966 if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) { 967 throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]); 968 } 969 } 970 } else { 971 _ps.executeBatch(); 972 } 973 974 _ps.clearBatch(); 975 } catch (SQLException se) { 976 throw new PersistenceDatabaseException(se); 977 } 978 979 _cacheValues.forEach((_cacheValue) -> { 980 PaymentMethodCreditCard _cacheEntity = new PaymentMethodCreditCard(_cacheValue, EntityPermission.READ_ONLY); 981 982 session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity); 983 }); 984 } 985 } 986 987 public void create(Collection<PaymentMethodCreditCardValue> _values) 988 throws PersistenceDatabaseException, PersistenceNotNullException { 989 create(ThreadSession.currentSession(), _values); 990 } 991 992 private boolean bindForStore(PreparedStatement _ps, PaymentMethodCreditCardValue _value) 993 throws SQLException { 994 boolean _hasBeenModified = _value.hasBeenModified(); 995 996 if(_hasBeenModified) { 997 PaymentMethodPK pmcc_pm_paymentmethodid = _value.getPaymentMethodPK(); 998 if(pmcc_pm_paymentmethodid == null) 999 _ps.setNull(1, Types.BIGINT); 1000 else 1001 _ps.setLong(1, pmcc_pm_paymentmethodid.getEntityId()); 1002 1003 Boolean pmcc_requestnameoncard = _value.getRequestNameOnCard(); 1004 if(pmcc_requestnameoncard == null) 1005 _ps.setNull(2, Types.BIT); 1006 else 1007 _ps.setInt(2, pmcc_requestnameoncard? 1: 0); 1008 1009 Boolean pmcc_requirenameoncard = _value.getRequireNameOnCard(); 1010 if(pmcc_requirenameoncard == null) 1011 _ps.setNull(3, Types.BIT); 1012 else 1013 _ps.setInt(3, pmcc_requirenameoncard? 1: 0); 1014 1015 Boolean pmcc_checkcardnumber = _value.getCheckCardNumber(); 1016 if(pmcc_checkcardnumber == null) 1017 _ps.setNull(4, Types.BIT); 1018 else 1019 _ps.setInt(4, pmcc_checkcardnumber? 1: 0); 1020 1021 Boolean pmcc_requestexpirationdate = _value.getRequestExpirationDate(); 1022 if(pmcc_requestexpirationdate == null) 1023 _ps.setNull(5, Types.BIT); 1024 else 1025 _ps.setInt(5, pmcc_requestexpirationdate? 1: 0); 1026 1027 Boolean pmcc_requireexpirationdate = _value.getRequireExpirationDate(); 1028 if(pmcc_requireexpirationdate == null) 1029 _ps.setNull(6, Types.BIT); 1030 else 1031 _ps.setInt(6, pmcc_requireexpirationdate? 1: 0); 1032 1033 Boolean pmcc_checkexpirationdate = _value.getCheckExpirationDate(); 1034 if(pmcc_checkexpirationdate == null) 1035 _ps.setNull(7, Types.BIT); 1036 else 1037 _ps.setInt(7, pmcc_checkexpirationdate? 1: 0); 1038 1039 Boolean pmcc_requestsecuritycode = _value.getRequestSecurityCode(); 1040 if(pmcc_requestsecuritycode == null) 1041 _ps.setNull(8, Types.BIT); 1042 else 1043 _ps.setInt(8, pmcc_requestsecuritycode? 1: 0); 1044 1045 Boolean pmcc_requiresecuritycode = _value.getRequireSecurityCode(); 1046 if(pmcc_requiresecuritycode == null) 1047 _ps.setNull(9, Types.BIT); 1048 else 1049 _ps.setInt(9, pmcc_requiresecuritycode? 1: 0); 1050 1051 String pmcc_cardnumbervalidationpattern = _value.getCardNumberValidationPattern(); 1052 if(pmcc_cardnumbervalidationpattern == null) 1053 _ps.setNull(10, Types.VARCHAR); 1054 else 1055 _ps.setString(10, pmcc_cardnumbervalidationpattern); 1056 1057 String pmcc_securitycodevalidationpattern = _value.getSecurityCodeValidationPattern(); 1058 if(pmcc_securitycodevalidationpattern == null) 1059 _ps.setNull(11, Types.VARCHAR); 1060 else 1061 _ps.setString(11, pmcc_securitycodevalidationpattern); 1062 1063 Boolean pmcc_retaincreditcard = _value.getRetainCreditCard(); 1064 if(pmcc_retaincreditcard == null) 1065 _ps.setNull(12, Types.BIT); 1066 else 1067 _ps.setInt(12, pmcc_retaincreditcard? 1: 0); 1068 1069 Boolean pmcc_retainsecuritycode = _value.getRetainSecurityCode(); 1070 if(pmcc_retainsecuritycode == null) 1071 _ps.setNull(13, Types.BIT); 1072 else 1073 _ps.setInt(13, pmcc_retainsecuritycode? 1: 0); 1074 1075 Boolean pmcc_requestbilling = _value.getRequestBilling(); 1076 if(pmcc_requestbilling == null) 1077 _ps.setNull(14, Types.BIT); 1078 else 1079 _ps.setInt(14, pmcc_requestbilling? 1: 0); 1080 1081 Boolean pmcc_requirebilling = _value.getRequireBilling(); 1082 if(pmcc_requirebilling == null) 1083 _ps.setNull(15, Types.BIT); 1084 else 1085 _ps.setInt(15, pmcc_requirebilling? 1: 0); 1086 1087 Boolean pmcc_requestissuer = _value.getRequestIssuer(); 1088 if(pmcc_requestissuer == null) 1089 _ps.setNull(16, Types.BIT); 1090 else 1091 _ps.setInt(16, pmcc_requestissuer? 1: 0); 1092 1093 Boolean pmcc_requireissuer = _value.getRequireIssuer(); 1094 if(pmcc_requireissuer == null) 1095 _ps.setNull(17, Types.BIT); 1096 else 1097 _ps.setInt(17, pmcc_requireissuer? 1: 0); 1098 1099 Long pmcc_fromtime = _value.getFromTime(); 1100 if(pmcc_fromtime == null) 1101 _ps.setNull(18, Types.BIGINT); 1102 else 1103 _ps.setLong(18, pmcc_fromtime); 1104 1105 Long pmcc_thrutime = _value.getThruTime(); 1106 if(pmcc_thrutime == null) 1107 _ps.setNull(19, Types.BIGINT); 1108 else 1109 _ps.setLong(19, pmcc_thrutime); 1110 1111 _ps.setLong(20, _value.getPrimaryKey().getEntityId()); 1112 1113 _value.clearHasBeenModified(); 1114 } 1115 1116 return _hasBeenModified; 1117 } 1118 1119 @Override 1120 public void store(Session session, PaymentMethodCreditCard entity) 1121 throws PersistenceDatabaseException { 1122 PreparedStatement _ps = session.prepareStatement(SQL_UPDATE); 1123 1124 try { 1125 PaymentMethodCreditCardValue _value = entity.getPaymentMethodCreditCardValue(); 1126 1127 if(bindForStore(_ps, _value)) { 1128 if(PersistenceDebugFlags.CheckEntityUpdateRowCount) { 1129 int _count = _ps.executeUpdate(); 1130 1131 if(_count != 1) { 1132 throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count); 1133 } 1134 } else { 1135 _ps.executeUpdate(); 1136 } 1137 1138 session.getValueCache().put(_value); 1139 } 1140 } catch (SQLException se) { 1141 throw new PersistenceDatabaseException(se); 1142 } 1143 } 1144 1145 @Override 1146 public void store(Session session, Collection<PaymentMethodCreditCard> entities) 1147 throws PersistenceDatabaseException { 1148 if(entities.size() > 0) { 1149 PreparedStatement _ps = session.prepareStatement(SQL_UPDATE); 1150 int _modifiedEntities = 0; 1151 1152 try { 1153 for(PaymentMethodCreditCard entity : entities) { 1154 if(bindForStore(_ps, entity.getPaymentMethodCreditCardValue())) { 1155 _ps.addBatch(); 1156 _modifiedEntities++; 1157 } 1158 } 1159 1160 if(_modifiedEntities != 0) { 1161 if(PersistenceDebugFlags.CheckEntityUpdateRowCount) { 1162 int[] _counts = _ps.executeBatch(); 1163 1164 for(int _countOffset = 0 ; _countOffset < _modifiedEntities ; _countOffset++) { 1165 if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) { 1166 throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]); 1167 } 1168 } 1169 } else { 1170 _ps.executeBatch(); 1171 } 1172 1173 _ps.clearBatch(); 1174 1175 entities.forEach((entity) -> { 1176 session.getValueCache().put(entity.getPaymentMethodCreditCardValue()); 1177 }); 1178 } 1179 } catch (SQLException se) { 1180 throw new PersistenceDatabaseException(se); 1181 } 1182 } 1183 } 1184 1185 @Override 1186 public void store(Collection<PaymentMethodCreditCard> entities) 1187 throws PersistenceDatabaseException { 1188 store(ThreadSession.currentSession(), entities); 1189 } 1190 1191 @Override 1192 public void remove(Session session, PaymentMethodCreditCard entity) 1193 throws PersistenceDatabaseException { 1194 remove(session, entity.getPrimaryKey()); 1195 } 1196 1197 @Override 1198 public void remove(Session session, PaymentMethodCreditCardPK pk) 1199 throws PersistenceDatabaseException { 1200 PreparedStatement _ps = session.prepareStatement(SQL_DELETE); 1201 long _entityId = pk.getEntityId(); 1202 1203 try { 1204 _ps.setLong(1, _entityId); 1205 1206 if(PersistenceDebugFlags.CheckEntityDeleteRowCount) { 1207 int _count = _ps.executeUpdate(); 1208 1209 if(_count != 1) { 1210 throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count); 1211 } 1212 } else { 1213 _ps.executeUpdate(); 1214 } 1215 1216 session.getValueCache().remove(pk); 1217 } catch (SQLException se) { 1218 throw new PersistenceDatabaseException(se); 1219 } 1220 1221 session.removed(pk, false); 1222 } 1223 1224 @Override 1225 public void remove(Session session, Collection<PaymentMethodCreditCardPK> pks) 1226 throws PersistenceDatabaseException { 1227 if(pks.size() > 0) { 1228 PreparedStatement _ps = session.prepareStatement(SQL_DELETE); 1229 int _modifiedEntities = 0; 1230 1231 try { 1232 for(PaymentMethodCreditCardPK pk : pks) { 1233 long _entityId = pk.getEntityId(); 1234 1235 _ps.setLong(1, _entityId); 1236 1237 _ps.addBatch(); 1238 _modifiedEntities++; 1239 } 1240 1241 if(_modifiedEntities != 0) { 1242 if(PersistenceDebugFlags.CheckEntityDeleteRowCount) { 1243 int[] _counts = _ps.executeBatch(); 1244 1245 for(int _countOffset = 0 ; _countOffset < _modifiedEntities ; _countOffset++) { 1246 if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) { 1247 throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]); 1248 } 1249 } 1250 } else { 1251 _ps.executeBatch(); 1252 } 1253 1254 _ps.clearBatch(); 1255 1256 pks.forEach((pk) -> { 1257 session.getValueCache().remove(pk); 1258 }); 1259 } 1260 } catch (SQLException se) { 1261 throw new PersistenceDatabaseException(se); 1262 } 1263 1264 pks.forEach((pk) -> { 1265 session.removed(pk, true); 1266 }); 1267 } 1268 } 1269 1270 @Override 1271 public void remove(Collection<PaymentMethodCreditCardPK> pks) 1272 throws PersistenceDatabaseException { 1273 remove(ThreadSession.currentSession(), pks); 1274 } 1275 1276 @Override 1277 public boolean validPK(Session session, PaymentMethodCreditCardPK pk) 1278 throws PersistenceDatabaseException { 1279 boolean valid = false; 1280 PreparedStatement _ps = session.prepareStatement(SQL_VALID); 1281 ResultSet _rs = null; 1282 1283 try { 1284 _ps.setLong(1, pk.getEntityId()); 1285 1286 _rs = _ps.executeQuery(); 1287 if(_rs.next()) { 1288 long _count = _rs.getLong(1); 1289 if(_rs.wasNull()) 1290 _count = 0; 1291 1292 if(_count == 1) 1293 valid = true; 1294 } 1295 } catch (SQLException se) { 1296 throw new PersistenceDatabaseException(se); 1297 } finally { 1298 if(_rs != null) { 1299 try { 1300 _rs.close(); 1301 } catch (SQLException se) { 1302 // do nothing 1303 } 1304 } 1305 } 1306 1307 return valid; 1308 } 1309 1310}