/** * Set Employer of the EmployerCandidateDO * * @param BDO-wrapped Employer of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public void setEmployer(jobmatch.data.EmployerBDO Employer) throws DataObjectException { try { // business actions/assertions prior to data assignment beforeAnySet(); } catch (Exception e) { throw new DataObjectException("beforeAnySet: " + e.getMessage()); } if (null == Employer) { if (false) DO.setEmployer(null); else throw new DataObjectException("EmployerCandidateBDO.setEmployer does not allow NULL."); } else { DO.setEmployer(Employer.getDO()); } afterAnySet(); // business actions/assertions after data assignment }
/** * Set Pensum of the EmployerCandidateDO * * @param Pensum of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public void setPensum(int Pensum) throws DataObjectException { try { // business actions/assertions prior to data assignment beforeAnySet(); } catch (Exception e) { throw new DataObjectException("beforeAnySet: " + e.getMessage()); } DO.setPensum(Pensum); afterAnySet(); // business actions/assertions after data assignment }
/** * Set Employer of the EmployerCandidateDO * * @param Employer of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public void setEmployer(jobmatch.data.EmployerDO Employer) throws DataObjectException { try { // business actions/assertions prior to data assignment beforeAnySet(); } catch (Exception e) { throw new DataObjectException("beforeAnySet: " + e.getMessage()); } DO.setEmployer(Employer); afterAnySet(); // business actions/assertions after data assignment }
/** * Set Candidate of the EmployerCandidateDO * * @param Candidate of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public void setCandidate(jobmatch.data.CandidateDO Candidate) throws DataObjectException { try { // business actions/assertions prior to data assignment beforeAnySet(); } catch (Exception e) { throw new DataObjectException("beforeAnySet: " + e.getMessage()); } DO.setCandidate(Candidate); afterAnySet(); // business actions/assertions after data assignment }
/** * Set EndDate of the EmployerCandidateDO * * @param EndDate of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public void setEndDate(java.sql.Date EndDate) throws DataObjectException { try { // business actions/assertions prior to data assignment beforeAnySet(); } catch (Exception e) { throw new DataObjectException("beforeAnySet: " + e.getMessage()); } DO.setEndDate(EndDate); afterAnySet(); // business actions/assertions after data assignment }
/** * Get Pensum of the EmployerCandidateDO * * @return Pensum of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public int getPensum() throws DataObjectException { beforeAnyGet(); // business actions/assertions prior to data return return DO.getPensum(); }
/** * Get Function of the EmployerCandidateDO * * @return Function of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public String getFunction() throws DataObjectException { beforeAnyGet(); // business actions/assertions prior to data return return DO.getFunction(); }
/** * Get BDO-wrapped Employer of the EmployerCandidateDO * * @return BDO-wrapped Employer of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public jobmatch.data.EmployerBDO getEmployerBDO() throws DataObjectException { beforeAnyGet(); // business actions/assertions prior to data return jobmatch.data.EmployerBDO b = jobmatch.data.EmployerBDO.createExisting(DO.getEmployer()); return b; }
/** * Get Employer of the EmployerCandidateDO * * @return Employer of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public jobmatch.data.EmployerDO getEmployer() throws DataObjectException { beforeAnyGet(); // business actions/assertions prior to data return return DO.getEmployer(); }
// beforeAnySet throws plain Exception to allow overriding implementations // to throw any flavor needed. protected void beforeAnySet() throws Exception { if (DO.isReadOnly()) throw new DataObjectException(DO + " is read-only."); }
/** * Get EndDate of the EmployerCandidateDO * * @return EndDate of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public java.sql.Date getEndDate() throws DataObjectException { beforeAnyGet(); // business actions/assertions prior to data return return DO.getEndDate(); }
/** * Get Candidate of the EmployerCandidateDO * * @return Candidate of the EmployerCandidateDO * @exception DataObjectException If the object is not found in the database. */ public jobmatch.data.CandidateDO getCandidate() throws DataObjectException { beforeAnyGet(); // business actions/assertions prior to data return return DO.getCandidate(); }
/** for debugging */ public String toString() { if (null == DO) return "NULL"; return DO.toString(); }
/** * @param handle <CODE>String</CODE> representation of the id for this BDO * @return boolean True if the string version of the id of this DO matches passed handle * @see getHandle */ public boolean hasMatchingHandle(String handle) { return DO.hasMatchingHandle(handle); }
/** * The methods <CODE> * getHandle * hasMatchingHandle * </CODE> are used by Presentation Objects that need to populate * HTML select lists with <CODE>EmployerCandidateBDO</CODE> objects as options. * * The <CODE>getHandle()</CODE> method is used * to set the value for each option, * and the <CODE>hasMatchingHandle()<CODE> * methods are used to lookup the Data Object when the selection has * been made. * * This EmployerCandidateBDO object holds a reference to a EmployerCandidateDO object. * The id of this EmployerCandidateBDO is the id of its EmployerCandidateDO. * @exception DatabaseManagerException * If a connection to the database cannot be established, etc. * @return id of this BDO as a string * If an object id can't be allocated for this object. */ public String getHandle() throws DatabaseManagerException { return DO.getHandle(); }
/** * Modifies the DO within its table. Performs recursive commit/delete on referenced DOs; all * operations occur within a single transaction to allow rollback in the event of error. Only the * creator of the transaction releases it. * * @param dbt The transaction object to use for this operation. * @param delete True if doing a delete, otherwise doing insert/update. * @exception com.lutris.appserver.server.sql.DatabaseManagerException if a Transaction can not be * created. * @exception RefAssertionException thrown by okTo method. * @exception java.sql.SQLException if any SQL errors occur. */ protected void modifyDO(DBTransaction dbt, boolean delete) throws SQLException, DatabaseManagerException, DataObjectException, RefAssertionException, DBRowUpdateException, QueryException { boolean ownTransaction = false; try { if (null == dbt) { DatabaseManager dbm = Enhydra.getDatabaseManager(); dbt = dbm.createTransaction(); // create a transaction ownTransaction = true; } if (null == dbt) throw new DatabaseManagerException("DatabaseManager.createTransaction returned null."); if (delete) { // Code to perform cascading deletes is generated here // if cascading deletes are not supported by the database. // The following line keeps the compiler happy // when the CASCADING_DELETES tag is empty. if (false) throw new QueryException("XXX"); } else { // commit referenced DOs. jobmatch.data.CandidateDO Candidate_DO = DO.getCandidate(); if (null != Candidate_DO) { if (Candidate_DO.isLoaded()) { okToCommitCandidate(Candidate_DO); jobmatch.data.CandidateBDO b = jobmatch.data.CandidateBDO.createExisting(Candidate_DO); b.commit(dbt); } else { // since the referenced DO is not loaded, // it cannot be dirty, so there is no need to commit it. } } else { if (!false) throw new RefAssertionException( "Cannot commit EmployerCandidateBDO ( " + toString() + " ) because Candidate is not allowed to be null."); } jobmatch.data.EmployerDO Employer_DO = DO.getEmployer(); if (null != Employer_DO) { if (Employer_DO.isLoaded()) { okToCommitEmployer(Employer_DO); jobmatch.data.EmployerBDO b = jobmatch.data.EmployerBDO.createExisting(Employer_DO); b.commit(dbt); } else { // since the referenced DO is not loaded, // it cannot be dirty, so there is no need to commit it. } } else { if (!false) throw new RefAssertionException( "Cannot commit EmployerCandidateBDO ( " + toString() + " ) because Employer is not allowed to be null."); } } if (false) { // This throw is here to keep the compiler happy // in the case of a DO that does not refer to other DOs. // In that case, the above delete/commit code blocks will be empty // and throw nothing. throw new DataObjectException("foo"); } if (delete) { dbt.delete(DO); } else { if (DO.isLoaded()) dbt.insert(DO); // dbt.insert() handles insertions and updates } if (ownTransaction) { dbt.commit(); // commit the transaction } } catch (DataObjectException doe) { throw doe; } catch (SQLException sqle) { StringBuffer message = new StringBuffer("Failed to insert/update DO: "); message.append(sqle.getMessage()); // rollback, if necessary if (ownTransaction) { try { dbt.rollback(); } catch (SQLException sqle2) { message.insert(0, "\n"); message.insert(0, sqle2.getMessage()); message.insert(0, "Rollback failed: "); } } throw new SQLException(message.toString()); } finally { // release the transaction, if any if (ownTransaction) { dbt.release(); } } }
/** Constructor required by <CODE>EmployerCandidateBDO.create</CODE> methods. */ public EmployerCandidateBDO() throws Exception { this.DO = EmployerCandidateDO.createVirgin(); }