protected function setRegistrationID()
{
// get registration ID for the rest of the reg. process
$regs = new RowManager_RegistrationManager();
$people = new RowManager_PersonManager();
$people->setPersonID($this->person_id);
$events = new RowManager_EventManager();
$events->setEventID($this->event_id);
$personRegs = new MultiTableManager();
$personRegs->addRowManager($regs);
$personRegs->addRowManager($people, new JoinPair($regs->getJoinOnPersonID(), $people->getJoinOnPersonID()));
$personRegs->addRowManager($events, new JoinPair($regs->getJoinOnEventID(), $events->getJoinOnEventID()));
$regsList = $personRegs->getListIterator();
$regsArray = $regsList->getDataList();
// echo "<pre>".print_r($regsArray,true)."</pre>";
reset($regsArray);
foreach (array_keys($regsArray) as $k) {
$registration = current($regsArray);
$this->registration_id = $registration['registration_id'];
// NOTE: should only be one reg. per person per event (ENFORCE??)
next($regsArray);
}
// create new registration record for this person (since none exists for current person-event combo)
if (!isset($this->registration_id)) {
// get status id for INITIAL_REG_STATUS
$regStatus = new RowManager_StatusManager();
$regStatus->setStatusDesc(FormProcessor_EditMyInfo::INITIAL_REG_STATUS);
$regStatusList = $regStatus->getListIterator();
$regStatusArray = $regStatusList->getDataList();
$statusID = 0;
reset($regStatusArray);
foreach (array_keys($regStatusArray) as $k) {
$status = current($regStatusArray);
$statusID = $status['status_id'];
// NOTE: should only be one reg. per person per event (ENFORCE??)
next($regStatusArray);
}
// get the MAX(registration_id)... need to determine what insertion registration ID will be (used in confirmNum)
$allRegs = new MultiTableManager();
$regs2 = new RowManager_RegistrationManager();
$allRegs->addRowManager($regs2);
$allRegs->setFunctionCall('MAX', 'registration_id');
$allRegs->ignoreFields();
// only leave MAX(registration_id) in values to be returned
$allRegsList = $allRegs->getListIterator();
$allRegsArray = $allRegsList->getDataList();
$maxID = -1;
reset($allRegsArray);
foreach (array_keys($allRegsArray) as $k) {
$regRecord = current($allRegsArray);
$maxID = $regRecord['MAX(registration_id)'];
if ($maxID > -1) {
break;
// get out of the loop once MAX is found
}
next($allRegsArray);
}
// compile values needed for new registration record
$regValues = array();
$nextRegID = $maxID + 1;
$regValues['event_id'] = $this->event_id;
// check if a new person record needs to be created
if ($this->person_id == -1) {
$this->person_id = $this->getNextPersonID();
// assumes processData() will properly use this value for insertion
// create empty person record to start off... since otherwise FK constraint on cim_reg_registration is NOT satisfied
$personManager = new RowManager_PersonManager($this->person_id);
$personManager->loadFromArray($this->formValues);
$personManager->setPersonID($this->person_id);
$personManager->createNewEntry(true);
//$this->assignCampus($this->person_id); -- save this step for when info properly entered into form
}
$regValues['person_id'] = $this->person_id;
$timestamp = strtotime("now");
$date = date('Y-m-d H:i:s', $timestamp);
// == NOW() : to bad I could pass that as non-string...
$regValues['registration_date'] = $date;
// set date-time to current date-time
$regValues['registration_confirmNum'] = 'E' . $this->event_id . 'R' . $nextRegID . 'C' . $this->campus_id;
$regValues['registration_status'] = $statusID;
// store values in table manager object.
$regs->loadFromArray($regValues);
// set primary key to use for update (if maxID found)
if ($maxID > -1) {
$regValues['registration_id'] = $nextRegID;
$regs->setRegID($regValues['registration_id']);
}
// now update the DB with the values
if (!$regs->isLoaded()) {
$regs->createNewEntry(true);
// allow primary key to be set (in case auto_increment is off)
$this->registration_id = $nextRegID;
}
// TODO: figure out how to show error if no registration made, or updated (IF it is even possible now...)
}
}
/**
* function loadSideBar
* <pre>
* Choosses .
* </pre>
* @return [void]
*/
function loadSideBar()
{
$regStatus = RowManager_RegistrationManager::STATUS_INCOMPLETE;
// get privileges for the current viewer
$privManager = new PrivilegeManager($this->viewer->getID());
// students allowed to see sidebar for sign-up process
if ($this->IS_IN_REG_PROCESS == modulecim_reg::IS_SIGNUP || $privManager->isCampusAdmin($this->EVENT_ID, $this->CAMPUS_ID) == true) {
// $parameters['PERSON_ID'] = $personID;
// find registration ID using person id and event_id
//if ((!isset($this->REG_ID))||$this->REG_ID='')
//{
if (isset($this->PERSON_ID) && $this->PERSON_ID != '' && (isset($this->EVENT_ID) && $this->EVENT_ID != '')) {
// get registration ID for the rest of the reg. process
$regs = new RowManager_RegistrationManager();
$people = new RowManager_PersonManager();
$people->setPersonID($this->PERSON_ID);
$events = new RowManager_EventManager();
$events->setEventID($this->EVENT_ID);
$personRegs = new MultiTableManager();
$personRegs->addRowManager($regs);
$personRegs->addRowManager($people, new JoinPair($regs->getJoinOnPersonID(), $people->getJoinOnPersonID()));
$personRegs->addRowManager($events, new JoinPair($regs->getJoinOnEventID(), $events->getJoinOnEventID()));
$regsList = $personRegs->getListIterator();
$regsArray = $regsList->getDataList();
// echo "<pre>".print_r($regsArray,true)."</pre>";
reset($regsArray);
foreach (array_keys($regsArray) as $k) {
$registration = current($regsArray);
$this->REG_ID = $registration['registration_id'];
// NOTE: should only be one reg. per person per event (ENFORCE??)
$regStatus = $registration['registration_status'];
next($regsArray);
}
}
//}
$regCompleted = false;
if ($regStatus == RowManager_RegistrationManager::STATUS_REGISTERED) {
$regCompleted = true;
}
$this->sideBar = new obj_RegProcessSideBar($this->moduleRootPath, $this->viewer, $regCompleted);
//, $isNewRegistrant );
$links = array();
// $adminLinks = array();
// $campusLevelLinks = array();
$parameters = array();
$parameters = array('MINISTRY_ID' => $this->MINISTRY_ID, 'IS_IN_REG_PROCESS' => $this->IS_IN_REG_PROCESS, 'EVENT_ID' => $this->EVENT_ID, 'REG_ID' => $this->REG_ID, 'PERSON_ID' => $this->PERSON_ID, 'CAMPUS_ID' => $this->CAMPUS_ID, 'PRIV_ID' => $this->PRIV_ID);
//[RAD_CALLBACK_PARAMS]
// 'PROVINCE_ID'=>$this->PROVINCE_ID, 'GENDER_ID'=>$this->GENDER_ID, 'STAFF_ID'=>$this->STAFF_ID, 'USER_ID'=>$this->USER_ID, 'ASSIGNMENT_ID'=>$this->ASSIGNMENT_ID, 'ADMIN_ID'=>$this->ADMIN_ID, 'CAMPUSADMIN_ID'=>$this->CAMPUSADMIN_ID
// echo print_r($parameters,true);
// GROUP 1: EVERYONE.
// ALL viewers can access these links
if ($regStatus == RowManager_RegistrationManager::STATUS_REGISTERED && $this->IS_IN_REG_PROCESS == modulecim_reg::IS_SIGNUP) {
$requestLink = $this->getCallBack(modulecim_reg::PAGE_CONFIRMCANCELREGISTRATION, '', $parameters);
$links['[RegCancel]'] = $requestLink;
}
$requestLink = $this->getCallBack(modulecim_reg::PAGE_EDITPERSONALINFO, '', $parameters);
$links['[editMyInfo]'] = $requestLink;
// need to know if registration process requires new registrant personal info
// since this means side-bar cannot have future registration step links yet
if (isset($this->PERSON_ID) && $this->PERSON_ID == -1) {
// show only first link
} else {
$requestLink = $this->getCallBack(modulecim_reg::PAGE_EDITCAMPUSASSIGNMENT, '', $parameters);
$links['[editCampusInfo]'] = $requestLink;
$requestLink = $this->getCallBack(modulecim_reg::PAGE_EDITFIELDVALUES, '', $parameters);
$links['[editFieldValues]'] = $requestLink;
$requestLink = $this->getCallBack(modulecim_reg::PAGE_PROCESSFINANCIALTRANSACTIONS, '', $parameters);
$links['[processFinances]'] = $requestLink;
}
/***
if ($this->IS_IN_REG_PROCESS == modulecim_reg::IS_SIGNUP)
{
$requestLink = $this->getCallBack( modulecim_reg::PAGE_REG_HOME, '' , $parameters);
$links[ '[backToEventList]' ] = $requestLink;
}
else if ($this->IS_IN_REG_PROCESS == modulecim_reg::IS_OFFLINE_REG)
{
$requestLink = $this->getCallBack( modulecim_reg::PAGE_EDITCAMPUSREGISTRATIONS, '' , $parameters);
$links[ '[backToRegList]' ] = $requestLink;
}
****/
// // GROUP 2: CAMPUS ADMINS AND ABOVE ONLY.
// if ( ( $this->accessPrivManager->hasSitePriv() ) || ( $this->accessPrivManager->hasCampusPriv() ) ){
// //$requestLink = $this->getCallBack( modulecim_hrdb::PAGE_PEOPLE );
// //$campusLevelLinks[ '[PeopleList]' ] = $requestLink;
// // TODO if you have 'hrdb campus' group access rights you can see these
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_PEOPLEBYCAMPUSES );
// $campusLevelLinks[ '[PeopleByCampuses]' ] = $requestLink;
// }
// // GROUP 3: SUPER ADMINS ONLY.
// if ( $this->accessPrivManager->hasSitePriv()){
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_CAMPUSES );
// $adminLinks[ '[editCampuses]' ] = $requestLink;
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_PROVINCES );
// $adminLinks[ '[editProvinces]' ] = $requestLink;
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_PRIVILEGES );
// $adminLinks[ '[editPrivileges]' ] = $requestLink;
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_STAFF );
// $adminLinks[ '[Staff]' ] = $requestLink;
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_ADMINS );
// $adminLinks[ '[Admins]' ] = $requestLink;
//
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_EDITCAMPUSASSIGNMENT );
// $adminLinks[ '[CampusAssignments]' ] = $requestLink;
// $requestLink = $this->getCallBack( modulecim_hrdb::PAGE_EDITCAMPUSASSIGNMENTSTATUSTYPES );
// $adminLinks[ '[AssignStatusTypes]' ] = $requestLink;
//
// }
// pass the links to the sidebar object
$this->sideBar->setLinks($links);
// $this->sideBar->setAdminLinks( $adminLinks );
// $this->sideBar->setCampusLevelLinks( $campusLevelLinks );
}
}
/**
* function __construct
* <pre>
* Initialize the object.
* </pre>
* @param $pathModuleRoot [STRING] The path to the module's root dir.
* @param $viewer [OBJECT] The viewer object.
* @param $sortBy [STRING] Field data to sort listManager by.
* @param $managerInit [INTEGER] Initialization value for the listManager.
* @return [void]
*/
function __construct($pathModuleRoot, $viewer, $customreport_id, $disable_heading = false)
{
$this->is_blank_page = false;
$this->disable_heading = $disable_heading;
// store field display types
$DISPLAY_FIELDS = $this->getDisplayFields($customreport_id);
parent::__construct($DISPLAY_FIELDS);
// parent::__construct( page_ViewCustomReport::DISPLAY_FIELDS );
$this->pathModuleRoot = $pathModuleRoot;
$this->viewer = $viewer;
$this->disableHeading = $disable_heading;
$this->customreport_id = $customreport_id;
$this->fields_id_array = array();
$this->listLabels = array();
// Get fields for the custom report; required for retrieving data in column format
// $columns = 'customfields_id,report_id,cim_hrdb_customfields.fields_id,count(person_id)';
$groupBy = 'cim_hrdb_customfields.fields_id';
$dbFunction = 'COUNT';
$funcParam = 'person_id';
$reportFields = new MultiTableManager();
$customfields = new RowManager_CustomFieldsManager();
$customfields->setReportID($this->customreport_id);
// TODO? error checking on ID
$fieldvalues = new RowManager_FormFieldValueManager();
$reportFields->addRowManager($customfields);
$reportFields->addRowManager($fieldvalues, new JoinPair($customfields->getJoinOnFieldID(), $fieldvalues->getJoinOnFieldID()));
// use GROUP BY and $dbFunction = 'COUNT' to quickly get summary data per campus
if ($groupBy != '') {
$reportFields->setGroupBy($groupBy);
//'campus_desc');
}
if ($dbFunction != '') {
$reportFields->setFunctionCall($dbFunction, $funcParam);
}
$reportFields->setSortOrder('COUNT(person_id) DESC');
// $reportFields->setFieldList($columns);
$customFieldsList = $reportFields->getListIterator();
$customFieldsArray = $customFieldsList->getDataList();
// echo '<pre>'.print_r($customFieldsArray,true).'</pre>';
$i = 0;
foreach (array_keys($customFieldsArray) as $key) {
$record = current($customFieldsArray);
$this->fields_id_array[$i] = $record['fields_id'];
$i++;
next($customFieldsArray);
}
// Ensure that the custom report has been given at least one field
if (count($this->fields_id_array) > 0) {
// Default sorting: by person name, since this is the only standard field
$this->sortBy = 'person_lname,person_fname';
// TODO: need to add person table to allow person_name sorting
// Now load the access Privilege manager of this viewer
$this->adminManager = new RowManager_AdminManager();
// Get the person ID
$accessManager = new RowManager_AccessManager();
$accessManager->loadByViewerID($this->viewer->getViewerID());
$personID = $accessManager->getPersonID();
// Get the permissions the person has.
$this->adminManager->loadByPersonID($personID);
$directed_staff = '';
$directed_people = '';
// Super-admin
if ($this->adminManager->hasSitePriv()) {
$this->access_level = page_ViewCustomReport::SUPERADMIN;
} else {
if ($this->adminManager->isStaff($viewer->getID())) {
$director_id = $this->getStaffIDfromViewerID();
$staffManager = new RowManager_StaffDirectorManager();
$staffManager->setDirectorID($director_id);
/* Retrieve all directors under the current director */
$hierarchy_result = $staffManager->getDirectorHierarchy($director_id);
$hierarchy_result->setFirst();
$hierarchy_array = array();
$directed_staff = '';
while ($hierarchy_result->moveNext()) {
$staff_ids = $hierarchy_result->getCurrentRow();
// echo 'array = <pre>'.print_r($hierarchy_array,true).'</pre>';
for ($lvl = 1; $lvl <= MAX_DIRECTOR_LEVELS; $lvl++) {
$staff_id = $staff_ids['staff_lvl' . $lvl];
if ($staff_id != null) {
$directed_staff .= $staff_id . ',';
}
}
}
if ($directed_staff != '') {
$directed_staff = substr($directed_staff, 0, -1);
$this->access_level = page_ViewCustomReport::DIRECTOR;
} else {
$directed_staff = page_ViewCustomReport::NON_DIRECTOR;
$this->access_level = page_ViewCustomReport::NON_DIRECTOR;
}
$personGetter = new MultiTableManager();
$person_info = new RowManager_PersonManager();
$staff = new RowManager_StaffManager();
$personGetter->addRowManager($person_info);
$personGetter->addRowManager($staff, new JoinPair($staff->getJoinOnPersonID(), $person_info->getJoinOnPersonID()));
$personGetter->addSearchCondition('staff_id in (' . $directed_staff . ')');
$staffPersonList = $personGetter->getListIterator();
$staffPersonArray = $staffPersonList->getDataList();
foreach (array_keys($staffPersonArray) as $key) {
$record = current($staffPersonArray);
$directed_people .= $record['person_id'] . ',';
next($staffPersonArray);
}
$directed_people = substr($directed_people, 0, -1);
//remove last comma
} else {
$this->access_level = page_ViewCustomReport::UNAUTHORIZED_DIRECTOR;
}
}
// Retrieve custom report fields and store them in data columns for easy display
$dataAccessObject = new MultiTableManager();
$person_manager = new RowManager_PersonManager();
$dataAccessObject->addRowManager($person_manager);
$fieldList = '';
$temp_tables = array();
for ($i = 0; $i < count($this->fields_id_array); $i++) {
$tempTableCreationSQLmaker = new MultiTableManager();
$fieldvalue_manager = new RowManager_FormFieldValueManager();
$fieldvalue_manager->setFieldID($this->fields_id_array[$i]);
// if ($this->access_level == page_ViewCustomReport::UNAUTHORIZED_DIRECTOR)
// {
// $fieldvalue_manager->setPersonID($personID); // only show staff's own data
// }
// else if ($this->access_level == page_ViewCustomReport::DIRECTOR)
// {
// $fieldvalue_manager->addSearchCondition('person_id in ('.$directed_people.')');
// }
// else if ($this->access_level == page_ViewCustomReport::NON_DIRECTOR) // director with no underlings
// {
// $fieldvalue_manager->setPersonID($personID); // only show staff's own data
// }
// else if ($this->access_level == page_ViewCustomReport::SUPERADMIN)
// {
// // no restrictions
// }
// Create a temporary table from a SQL join retrieving the data for a particular form field
$tempTableCreationSQLmaker->addRowManager($fieldvalue_manager);
$fields_manager = new RowManager_FormFieldManager();
$tempTableCreationSQLmaker->addRowManager($fields_manager, new JoinPair($fieldvalue_manager->getJoinOnFieldID(), $fields_manager->getJoinOnFieldID()));
$customfields_manager = new RowManager_CustomFieldsManager();
$customfields_manager->setReportID($this->customreport_id);
$tempTableCreationSQLmaker->addRowManager($customfields_manager, new JoinPair($fieldvalue_manager->getJoinOnFieldID(), $customfields_manager->getJoinOnFieldID()));
$tempFieldList = 'person_id,fieldvalues_value';
$tempTableCreationSQLmaker->setFieldList($tempFieldList);
$tempTableCreationSQL = $tempTableCreationSQLmaker->createSQL();
$temp_tables[$i] = new TempTableManager('temptable' . $i, $tempTableCreationSQL, $tempFieldList, 'temptable' . $i);
//$PRIMARY_ID=-1
$temp_tables[$i]->createTable(true);
// Join the temporary tables together to get a table of n+1 columns where n = count($this->field_ids_array) and the extra column stores person_id
if ($i > 0) {
$fieldList .= ',temptable' . $i . '.fieldvalues_value as value' . $i;
$i_minus = $i - 1;
$dataAccessObject->addRowManager($temp_tables[$i], new JoinPair($temp_tables[$i_minus]->getJoinOnFieldX(page_ViewCustomReport::JOIN_FIELD), $temp_tables[$i]->getJoinOnFieldX(page_ViewCustomReport::JOIN_FIELD), JOIN_TYPE_LEFT));
} else {
$fieldList .= 'cim_hrdb_person.person_id,temptable' . $i . '.fieldvalues_value as value' . $i;
$dataAccessObject->addRowManager($temp_tables[0], new JoinPair($person_manager->getJoinOnFieldX(page_ViewCustomReport::JOIN_FIELD), $temp_tables[0]->getJoinOnFieldX(page_ViewCustomReport::JOIN_FIELD)));
}
}
// Filter results by directed people IDs (if viewer is NOT super-admin)
if ($this->access_level != page_ViewCustomReport::SUPERADMIN) {
// for ($i=0; $i < count($this->fields_id_array); $i++)
// {
// if ($this->access_level == page_ViewCustomReport::UNAUTHORIZED_DIRECTOR)
// {
// $dataAccessObject->addSearchCondition('temptable'.$i.'.person_id in ('.$personID.')'); // only show staff's own data
// }
// else if ($this->access_level == page_ViewCustomReport::DIRECTOR)
// {
// $dataAccessObject->addSearchCondition('temptable'.$i.'.person_id in ('.$directed_people.')');
// }
// else if ($this->access_level == page_ViewCustomReport::NON_DIRECTOR) // director with no underlings
// {
// $dataAccessObject->addSearchCondition('temptable'.$i.'.person_id in ('.$personID.')'); // only show staff's own data
// }
// }
$dataAccessObject->addSearchCondition('cim_hrdb_person.person_id in (' . $directed_people . ')');
}
// echo '<pre>'.print_r($temp_tables[0]->getListIterator()->getDataList(),true).'</pre>';
// $temp_tables[0]->db->runSQL('select * from temptable0');
$dataAccessObject->setFieldList($fieldList);
$dataAccessObject->setSortOrder($this->sortBy);
$this->listManager = $dataAccessObject->getListIterator();
// echo '<pre>'.print_r($this->listManager->getDataList(),true).'</pre>';
} else {
$dataAccessObject = new MultiTableManager();
$person_manager = new RowManager_PersonManager();
$person_manager->setPersonID(page_ViewCustomReport::NO_FIELDS_SET);
$dataAccessObject->addRowManager($person_manager);
$dataAccessObject->setSortOrder($this->sortBy);
$this->listManager = $dataAccessObject->getListIterator();
$this->is_blank_page = true;
}
// now initialize the labels for this page
// start by loading the default field labels for this Module
$languageID = $viewer->getLanguageID();
$seriesKey = modulecim_hrdb::MULTILINGUAL_SERIES_KEY;
$pageKey = modulecim_hrdb::MULTILINGUAL_PAGE_FIELDS;
$this->labels = new MultilingualManager($languageID, $seriesKey, $pageKey);
// then load the page specific labels for this page
$pageKey = page_ViewCustomReport::MULTILINGUAL_PAGE_KEY;
$this->labels->loadPageLabels($pageKey);
$this->labels->setSeriesKey(SITE_LABEL_SERIES_SITE);
$this->labels->loadPageLabels(SITE_LABEL_PAGE_FORM_LINKS);
$this->listLabels = $this->getListLabels($this->customreport_id);
// NOTE: parameter *required*
// foreach (array_keys($this->listLabels,true) as $key)
// {
// $label = current($this->listLabels);
// $this->labels->setLabelTag('[title_value0]', '<title in tool_setup>', 'Monthly Support Goal'); // NOTE: cannot be used because nothing set in tool_setup
// echo 'labels = <pre>'.print_r($this->listLabels,true).'</pre>';
}
/**
* function getHTML
* <pre>
* This method returns the HTML data generated by this object.
* </pre>
* @return [STRING] HTML Display data.
*/
function getHTML()
{
// Uncomment the following line if you want to create a template
// tailored for this page:
//$path = $this->pathModuleRoot.'templates/';
// Otherwise use the standard Templates for the site:
$path = SITE_PATH_TEMPLATES;
/*
* store the link values
*/
// example:
// $this->linkValues[ 'view' ] = 'add/new/href/data/here';
// store the link labels
$this->linkLabels['edit'] = $this->labels->getLabel('[Edit]');
$this->linkLabels['del'] = $this->labels->getLabel('[Delete]');
$this->linkLabels['cont'] = $this->labels->getLabel('[Continue]');
// $this->linkLabels[ 'view' ] = 'new link label here';
/*
* store any additional link Columns
*/
// example:
//$title = $this->labels->getLabel( '[title_groups]');
//$columnLabel = $this->labels->getLabel( '[groups]');
//$link = $this->linkValues[ 'groups' ];
//$fieldName = 'accessgroup_id';
//$this->addLinkColumn( $title, $columnLabel, $link, $fieldName);
/*
* Update any label tags ...
*/
// example:
// $name = $user->getName();
// $this->labels->setLabelTag( '[Title]', '[userName]', $name);
// NOTE: this parent method prepares the $this->template with the
// common AdminBox data.
$this->prepareTemplate($path);
// store the statevar id to edit
$this->template->set('editEntryID', $this->assignment_id);
$this->template->set('notice', $this->notice);
$this->template->set('errorMessage', $this->error_message);
// store all the fields to the template
$this->setFormFieldsToTemplate();
/*
* Form related Template variables:
*/
/*
* Insert the date start/end values for the following date fields:
*/
// example:
//$this->template->set( 'startYear_[fieldName]', 2000);
//$this->template->set( 'endYear_[fieldName]', 2010);
/*
* List related Template variables :
*/
// store the primary key field name for the data being displayed
$this->template->set('primaryKeyFieldName', 'assignment_id');
// store data list to the template
// NOTE: we initialize it here to make sure we capture any new data
// from a recent processData() call.
$dataAccessManager = new RowManager_EditCampusAssignmentManager();
$dataAccessManager->setPersonID($this->person_id);
if ($this->campus_id != '') {
$dataAccessManager->setCampusID($this->campus_id);
}
$dataAccessManager->setSortOrder($this->sortBy);
$this->dataList = $dataAccessManager->getListIterator();
// Store the XML Node name for the Data Access Field List
$xmlNodeName = $this->dataList->getRowManagerXMLNodeName();
//RowManager_EditCampusAssignmentManager::XML_NODE_NAME;
$this->template->set('rowManagerXMLNodeName', $xmlNodeName);
$this->template->setXML('dataList', $this->dataList->getXML());
// enable drop-down list for adding new person assignments
$personManager = new RowManager_PersonManager();
$campusManager = new RowManager_CampusManager();
/* $combinedManager = new MultiTableManager();
$combinedManager->addRowManager($personManager);
$combinedManager->addRowManager($dataAccessManager, new JoinPair($personManager->getJoinOnPersonID(),$dataAccessManager->getJoinOnPersonID()));
// $combinedManager->addRowManager($campusManager, new JoinPair($campusManager->getJoinOnCampusID(),$dataAccessManager->getJoinOnCampusID()));
if ($this->person_id!='') {
$combinedManager->constructSearchCondition( 'person_id', '=', $this->person_id, true );
}
if ($this->campus_id!='') {
$combinedManager->constructSearchCondition( 'campus_id', '=', $this->campus_id, true );
}
$dataList = $combinedManager->getListIterator();
$dataArray = $dataList->getDropListArray(); /**/
// $personManager = new RowManager_PersonManager($this->person_id);
// $personList = $personManager->getListIterator();
// $personArray = $personList ->getDropListArray();
// $this->template->set( 'list_person_id', $personArray );
// $personList = $combinedManager->getListIterator();
$personManager->setPersonID($this->person_id);
$personManager->setLabelTemplateLastNameFirstName();
$personList = $personManager->getListIterator();
$personArray = $personList->getDropListArray();
$this->template->set('list_person_id', $personArray);
// enable drop-down list for adding new campus assignments
if ($this->campus_id != '') {
$campusManager->setCampusID($this->campus_id);
}
$campusList = $campusManager->getListIterator();
// $campusList = $combinedManager->getListIterator();
$campusArray = $campusList->getDropListArray();
$this->template->set('list_campus_id', $campusArray);
// enable drop-down list for adding new campus assignments
$statusManager = new RowManager_CampusAssignmentStatusManager();
$statusList = $statusManager->getListIterator();
// $statusList = $combinedManager->getListIterator();
$statusArray = $statusList->getDropListArray();
$this->template->set('list_assignmentstatus_id', $statusArray);
// $dataAccessManager->setPersonID($this->person_id);
// $dataAccessManager->setCampusID($this->campus_id);
// $this->dataList = new EditCampusAssignmentList( $this->sortBy );
// $this->dataList = $combinedManager->getListIterator();
/*
* Add any additional data required by the template here
*/
// $this->displayValues =
$templateName = 'siteAdminBox.php';
// if you are creating a custom template for this page then
// replace $templateName with the following:
//$templateName = 'page_EditCampusAssignment.php';
return $this->template->fetch($templateName);
}
protected function getFieldValuesArray($regID = '', $personID = '', $eventID = '')
{
$FALSE = 0;
$fields = new RowManager_FieldManager();
$fvalues = new RowManager_FieldValueManager();
$ftypes = new RowManager_FieldTypeManager();
// echo "personID = ".$personID;
// echo "eventID = ".$eventID;
if ($regID != '') {
//$fields->setEventID($eventID);
$fvalues->setRegID($regID);
} else {
if ($eventID != '' && $personID != '') {
$registrations = new RowManager_RegistrationManager();
// $registrations->setRegID($regID);
$person = new RowManager_PersonManager();
$person->setPersonID($personID);
$event = new RowManager_EventManager();
$event->setEventID($eventID);
$personReg = new MultiTableManager();
$personReg->addRowManager($registrations);
$personReg->addRowManager($person, new JoinPair($registrations->getJoinOnPersonID(), $person->getJoinOnPersonID()));
$personReg->addRowManager($event, new JoinPair($registrations->getJoinOnEventID(), $event->getJoinOnEventID()));
$valIterator = $personReg->getListIterator();
$valArray = $valIterator->getDataList();
// go through results and store field types
reset($valArray);
foreach (array_keys($valArray) as $k) {
$regValue = current($valArray);
$regID = $regValue['registration_id'];
//NOTE: assumes only 1 registration per person per event
next($valArray);
}
// $fields->setEventID($eventID);
$fvalues->setRegID($regID);
}
}
// $fvalues->setSortByFieldID();
$fieldInfo = new MultiTableManager();
$fieldInfo->addRowManager($fields);
$fieldInfo->addRowManager($fvalues, new JoinPair($fvalues->getJoinOnFieldID(), $fields->getJoinOnFieldID()));
$fieldInfo->addRowManager($ftypes, new JoinPair($fields->getJoinOnFieldTypeID(), $ftypes->getJoinOnFieldTypeID()));
if ($this->show_hidden == false) {
$fieldInfo->constructSearchCondition('fields_hidden', '=', $FALSE, true);
}
$fieldInfo->setSortOrder('fields_priority');
$valuesIterator = $fieldInfo->getListIterator();
$valuesArray = $valuesIterator->getDataList();
// echo "field values:<br><pre>".print_r($valuesArray,true)."</pre>";
// store field ids associated with values already in database
$initializedFieldIds = array_keys($valuesArray);
// since each field value is located in a DB row the result array has several arrays - one per field value
// need to extract each field value and store it as a non-array record in a result array
$fieldValues = array();
$idx = 0;
/** Go through all event fields and map each to existing field value, otherwise create new field value record **/
$fieldsArray = array_values($this->formFieldToFieldIDmapper);
// store field IDs (ASSUMES formFieldToFieldIDmapper is initialized)
// echo 'fieldsArray = <pre>'.print_r($fieldsArray,true).'</pre>';
reset($fieldsArray);
reset($valuesArray);
foreach (array_keys($fieldsArray) as $k) {
$fieldID = current($fieldsArray);
$form_value = '';
// default blank field value if none found
$form_value_id = -1;
// to be replaced with existing or newly-created field values ID
if (in_array($fieldID, $initializedFieldIds) == true) {
$record = $valuesArray[$fieldID];
$form_value = $record['fieldvalues_value'];
$form_value_id = $record['fieldvalues_id'];
} else {
$updateValues = array();
$updateValues['fields_id'] = $fieldID;
$updateValues['fieldvalues_value'] = $form_value;
$updateValues['registration_id'] = $regID;
$fieldvalues_manager = new RowManager_FieldValueManager();
// store values in table manager object.
$fieldvalues_manager->loadFromArray($updateValues);
// now update the DB with the values
if (!$fieldvalues_manager->isLoaded()) {
$fieldvalues_manager->createNewEntry(true);
$form_value_id = $fieldvalues_manager->getID();
}
}
$fieldValues['form_field' . $idx] = $form_value;
// store mapping associating form field label with fieldvalues_id
$this->formFieldToValueIDmapper['form_field' . $idx] = $form_value_id;
next($fieldsArray);
$idx++;
}
// echo 'labels-values = <pre>'.print_r($this->formFieldToValueIDmapper,true).'</pre>';
// echo 'labels-fields = <pre>'.print_r($this->formFieldToFieldIDmapper,true).'</pre>';
return $fieldValues;
}
/**
* function getHTML
* <pre>
* This method returns the HTML data generated by this object.
* </pre>
* @return [STRING] HTML Display data.
*/
function getHTML()
{
// initialize the variable storing process report data
$reportDataDump = '';
$BR = '<BR>';
$HR = '<HR>';
// Make a new Template object
$path = $this->pathModuleRoot . 'templates/';
// $path = SITE_PATH_TEMPLATES;
// Replace $path with the following line if you want to create a
// template tailored for this page:
//$path = $this->pathModuleRoot.'templates/';
// store the link values
// $this->linkValues[ 'view' ] = 'add/new/href/data/here';
// store the link labels
$this->linkLabels['cont'] = $this->labels->getLabel('[GoBack]');
// store any additional link Columns
// example:
//$title = $this->labels->getLabel( '[title_groups]');
//$columnLabel = $this->labels->getLabel( '[groups]');
//$link = $this->linkValues[ 'groups' ];
//$fieldName = 'accessgroup_id';
//$this->addLinkColumn( $title, $columnLabel, $link, $fieldName);
// store the page labels
// NOTE: use this location to update any label tags ...
// example:
// $name = $user->getName();
// $this->labels->setLabelTag( '[Title]', '[userName]', $name);
$this->prepareTemplate($path);
/** Get list of unique triples of first name, last name, and e-mail address **/
// $allPeople = array(); // NOT USED BECAUSE WE HAVE NESTED LOOP INSTEAD OF MULTIPLE LOOPS
$personRecords = new MultiTableManager();
$personRecords->addRowManager($this->person_manager);
$personRecords->setSortOrder('person_lname');
// echo 'filters = '.$this->filter_fname.', '.$this->filter_lname.', '.$this->filter_email;
/**** DATA FILTERS: USED TO ENSURE 60 SEC TIME-OUT IS NOT VIOLATED ****/
$personRecords->addSearchCondition("person_fname like '" . $this->filter_fname . "%'");
$personRecords->addSearchCondition("person_lname like '" . $this->filter_lname . "%'");
$personRecords->addSearchCondition("person_email like '" . $this->filter_email . "%'");
// use GROUP BY to easily enforce distinct triplets of (person_fname, person_lname, person_email)
$groupBy = "person_fname,person_lname,person_email";
$personRecords->setGroupBy($groupBy);
$personData = $personRecords->getListIterator();
$personDataArray = $personData->getDataList();
/** Go through the list of names 1 by 1, running another query to find if duplicates exist **/
reset($personDataArray);
foreach (array_keys($personDataArray) as $k) {
$savedPersonID = -1;
// the only person ID left in the database for this individual
$person = current($personDataArray);
$person_fname = $person['person_fname'];
$person_lname = $person['person_lname'];
$person_email = $person['person_email'];
$reportDataDump .= 'Unique person record tuple:' . $BR . ' First Name = ' . $person_fname . ', Last Name = ' . $person_lname . ', E-mail = ' . $person_email . $BR . $BR;
// echo "PERSON NAME: ".$person_fname." ".$person_lname;
// echo "PERSON: <pre>".print_r($person,true)."</pre>";
// search for a particular person to see if duplicate records exist
$indiv_person_manager = new RowManager_PersonManager();
$indiv_person_manager->setFirstName(addslashes($person_fname));
// use addslashes to escape special chars in string
$indiv_person_manager->setLastName(addslashes($person_lname));
$indiv_person_manager->setEmail(addslashes($person_email));
$indiv_person_manager->setSortOrder('person_id');
$indiv_person_manager->setAscDesc('DESC');
// sort by descending person IDs
$indivData = $indiv_person_manager->getListIterator();
$indivDataArray = $indivData->getDataList();
// echo " INDIV COUNT: ".count($indivDataArray)."<br><br>";
// echo "INDIV RECORDS: <pre>".print_r($indivDataArray,true)."</pre>";
$person_ids_list = '';
//return all the person's data into array (key = person_id) of arrays (and store total data stored?)
if (isset($indivDataArray)) {
if (count($indivDataArray) == 0) {
echo "ERROR: person was found earlier and now NO records are found!";
} else {
if (count($indivDataArray) == 1) {
// echo "GREAT! This person only has one record.";
reset($indivDataArray);
$record = current($indivDataArray);
$savedPersonID = $record['person_id'];
$person_ids_list = $savedPersonID;
$reportDataDump .= 'Unique person id found for tuple: ' . $savedPersonID . $BR . $BR;
} else {
if (count($indivDataArray) > 1) {
// get the person IDs for this individual
reset($indivDataArray);
foreach (array_keys($indivDataArray) as $l) {
$record = current($indivDataArray);
$person_ids_list .= $record['person_id'];
$person_ids_list .= ',';
next($indivDataArray);
}
$person_ids_list = substr($person_ids_list, 0, -1);
// remove final comma
$reportDataDump .= 'Multiple person ids found for tuple: ' . $person_ids_list . $BR . $BR;
}
}
}
// Search for duplicate person-related entries - for 1 or more person_ids found for current person
if ($person_ids_list != '') {
// echo "<br> person ids list: ".$person_ids_list."<br>";
// $person_ids_array = explode($person_ids_list,',');
// check access table using all the found person IDs - retrieve viewer ids with person id as key
$foundViewerIDs = $this->getAccessRecords($person_ids_list);
// can safely assume array ISSET
// echo 'found viewer ids= <pre>'.print_r($foundViewerIDs,true).'</pre>';
/** IF 0 access table records were found: **/
if (count($foundViewerIDs) == 0) {
// TODO?: notify admin that this/these person record(s) require a viewer account
// Store the active (latest) person_id in special variable
reset($indivDataArray);
$savedPersonID = key($indivDataArray);
// recall that person_ids are sorted in descending order
} else {
if (count($foundViewerIDs) >= 1) {
// echo "<br>found viewer IDs: <pre>".print_r($foundViewerIDs, true)."</pre>";
/** Get the associated viewer_id with the most recent login date **/
// $viewers = new RowManager_ViewerManager();
// $viewer_ids = '';
// reset($foundViewerIDs);
// foreach (array_keys($foundViewerIDs) as $key)
// {
// // $record = current($foundViewerIDs);
// $viewer_ids .= $key.','; //$record //
// next($foundViewerIDs);
// }
// $viewer_ids = substr($viewer_ids, 0, -1); // remove final comma
// // echo 'viewer_ids list = '.$viewer_ids.'<br>';
// $viewers->addSearchCondition("viewer_id in (".$viewer_ids.")");
//
// $viewersData = $viewers->getListIterator();
// $viewersArray = $viewersData->getDataList();
//
// // echo 'viewers array data = <pre>'.print_r($viewersArray,true).'</pre>';
//
// $mostRecentDate = '0000-00-00';
// $mostRecentViewer = -1;
// reset($viewersArray);
// foreach(array_keys($viewersArray) as $l)
// {
// $record = current($viewersArray);
// $foundDate = $record['viewer_lastLogin'];
// $viewerID = $record['viewer_id'];
//
// // update most recent date if a more recent login date was found
// if ($foundDate > $mostRecentDate)
// {
// $mostRecentDate = $foundDate;
// $mostRecentViewer = $viewerID; // set viewer_id to use
// }
// }
// TODO: add loop here to check if all $foundViewerIDs (from access table) are in viewers table
// <loop>
// if (in_array($foundViewerIDs[index], array_keys($viewersArray)))
// delete $foundViewerIDs[index] from access table
// <end-loop>
// echo 'most recent viewer id = '.$mostRecentViewer;
// echo 'viewer ids from list = <pre>'.print_r(array_keys($foundViewerIDs),true).'</pre>';
/** store the active (access table) person_id in special variable **/
reset($foundViewerIDs);
// // (NEW) == person_id associated with the viewer_id having the most recent login date
// // ONLY IN THE CASE WHERE PERSON HAS MORE THAN 1 VIEWER_ID
// if (($mostRecentViewer != -1)&&(count($viewersArray) > 1))
// {
// $temp_viewerIDs = array_keys($foundViewerIDs); // gets the viewer ids
// $temp_personIDs = array_values($foundViewerIDs); // gets the person ids
// $index = array_search($mostRecentViewer, $temp_viewerIDs); // get index having most recent viewer_id
//
// $savedPersonID = $temp_personIDs[$index];
// $reportDataDump .= 'Person ID of the record to keep: '.$savedPersonID.' (associated with most recent login)'.$BR.$BR;
// }
// else // FORMERLY: (OLD) == latest viewer-associated person ID, since array is ordered by person_id (DESC)
// {
$personIDs = explode(',', $person_ids_list);
$savedPersonID = current($personIDs);
//current($foundViewerIDs);
$reportDataDump .= 'Person ID of the record to keep: ' . $savedPersonID . ' (associated with the most recent person record)' . $BR . $BR;
// }
// echo 'latest viewer ids = <pre>'.print_r($foundViewerIDs,true).'</pre>';
// echo 'saved person ID = '.$savedPersonID;
$reportDataDump .= 'Changes made to <b>cim_hrdb_access table</b>: ' . $BR;
/*** update the access table records to only use latest person ID **/
foreach (array_values($foundViewerIDs) as $person_id) {
$viewer_id = key($foundViewerIDs);
// echo 'viewer_id = '.$viewer_id;
// only update the access table record if it needs a different person_id
if ($person_id != $savedPersonID) {
// get access ID(s) for the record to change
$accessManager = new RowManager_AccessManager();
$accessManager->setViewerID($viewer_id);
$accessManager->setPersonID(current($foundViewerIDs));
// or just use $person_id
$accessData = $accessManager->getListIterator();
$accessDataArray = $accessData->getDataList();
// echo 'access data array = <pre>'.print_r($accessDataArray,true).'</pre>';
reset($accessDataArray);
// deal with the unlikely case that we have redundant viewerID-personID records
foreach (array_keys($accessDataArray) as $key) {
$record = current($accessDataArray);
$accessID = $record['access_id'];
// set the values to set in the record (using 'access_id' as search key)
$updateValues = array();
$updateValues['access_id'] = $accessID;
$updateValues['viewer_id'] = $viewer_id;
$updateValues['person_id'] = $savedPersonID;
// only data that is changed
$reportDataDump .= 'Updating person_id ' . $person_id . ' to be ' . $savedPersonID . $BR . $BR;
$accessManager->loadFromArray($updateValues);
$accessManager->updateDBTable();
next($accessDataArray);
}
}
$id = next($foundViewerIDs);
// person_id
if ($id === FALSE) {
break;
// no valid data found so break out of the loop
}
}
}
}
/** <end> access table update **/
$baseRecord = $indivDataArray[$savedPersonID];
// echo "<br>base record: <pre>".print_r($baseRecord,true)."</pre><br>";
$flagArray = $this->checkPersonRecordFields($baseRecord);
// echo "<br>flag array: <pre>".print_r($flagArray,true)."</pre><br>";
// Add data from other records to the stored latest person record, if required
// (i.e. if latest data misses phone #, etc)
reset($indivDataArray);
foreach (array_keys($indivDataArray) as $id) {
$record = current($indivDataArray);
$personID = $record['person_id'];
if ($personID != $savedPersonID) {
$personUpdater = new RowManager_PersonManager();
$personUpdater->setPersonID($savedPersonID);
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
// just to make sure...
$nextFlagArray = $this->checkPersonRecordFields($indivDataArray[$personID]);
// echo "<br>next flag array: <pre>".print_r($nextFlagArray,true)."</pre><br>";
reset($flagArray);
foreach (array_keys($flagArray) as $m) {
// if field is empty in active record then
// replace with most recent value - if one exists
// (since we are going through a list of person ids
// in descending order)
$flag = current($flagArray);
if ($flag == '0') {
$fieldName = key($flagArray);
// check if the replacement person record has a non-empty field
if ($nextFlagArray[$fieldName] == '1') {
$updateValues[$fieldName] = $record[$fieldName];
$flagArray[$fieldName] = '1';
// prevents less-recent person data to overwrite what was just written
}
}
next($flagArray);
}
// echo "<br>update values: <pre>".print_r($updateValues,true)."</pre><br>";
// update the active person record (in database)
if (count($updateValues) > 1) {
$reportDataDump .= 'Adding the following data to our preferred <b>cim_hrdb_person</b> record (using given person_id): ';
$reportDataDump .= '<pre>' . print_r($updateValues, true) . '</pre>' . $BR . $BR;
$personUpdater->loadFromArray($updateValues);
$personUpdater->updateDBTable();
}
}
next($indivDataArray);
}
}
// end "if >1 person id found for the person data"
/** Go through various tables and clean out or update records related to the current person **/
// Update and clean-up the Person-Year table (cim_hrdb_person_year)
// Step 1) Find the information stored for the active person_id
$personYearArray = array();
$person_year_manager = new RowManager_PersonYearManager();
$person_year_manager->setPersonID($savedPersonID);
$person_year_manager->setSortOrder('personyear_id');
$person_year_manager->setAscDesc('DESC');
// sort by descending personyear IDs
// echo "<BR>".$savedPersonID.",";
$personYearData = $person_year_manager->getListIterator();
$person_year_array = $personYearData->getDataList();
reset($person_year_array);
foreach (array_keys($person_year_array) as $key) {
$record = current($person_year_array);
$person_year_id = $record['personyear_id'];
$year_id = $record['year_id'];
$personYearArray[$person_year_id] = $year_id;
// store person_id associated with the person_year_id
next($person_year_array);
}
// if (count($person_year_array) > 0)
// {
// echo "<br>Years for active person_id ".$savedPersonID.": <pre>".print_r($personYearArray,true)."</pre><br>";
// }
// echo "Person IDs list: ".$person_ids_list."<br>";
$reportDataDump .= 'Changes made to <b>cim_hrdb_person_year table</b>: ' . $BR;
// remove all but the most recent person-year record (associated with active person id)
if (count($personYearArray) > 1) {
reset($personYearArray);
$person_year_id = key($personYearArray);
$reportDataDump .= 'Saving the first person year record associated with person ID ' . $savedPersonID . $BR . $BR;
next($personYearArray);
// keep the first record (most recent personyear_id
foreach (array_keys($personYearArray) as $m) {
$record = current($personYearArray);
$personYearID = key($personYearArray);
// echo "REMOVE person-year entry for person_id = ".$savedPersonID." using key = ".key($personYearArray);
if (isset($personYearID) && $personYearID != '' && $personYearID > 0) {
$reportDataDump .= 'Deleting redundant person year record having year ID ' . $record . $BR . $BR;
$personYearUpdater = new RowManager_PersonYearManager($personYearID);
$personYearUpdater->deleteEntry();
}
next($personYearArray);
}
}
// Step 2) Update the records having the non-active person ids for this person
$person_year_manager2 = new RowManager_PersonYearManager();
$person_year_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$person_year_manager2->setSortOrder('person_id');
$person_year_manager2->setAscDesc('DESC');
// sort by descending person IDs
$personYearData2 = $person_year_manager2->getListIterator();
$person_year_array2 = $personYearData2->getDataList();
// echo "<br>Years for ALL person_ids: <pre>".print_r($person_year_array2,true)."</pre><br>";
// If no record was found for the active person record - then set flag for updating
$updated = true;
if (count($personYearArray) < 1) {
$updated = false;
}
reset($person_year_array2);
$j = 0;
foreach (array_keys($person_year_array2) as $l) {
$record = current($person_year_array2);
$personID = $record['person_id'];
// We ignore records with the active person id - since we dealt with those redundancies already
if ($personID != $savedPersonID) {
// echo "FOUND person ".$personID;
$person_year_id = $record['personyear_id'];
$personYearUpdater = new RowManager_PersonYearManager($person_year_id);
// $personYearUpdater->setPersonYearID($person_year_id);
$person_id = $record['person_id'];
$year_id = $record['year_id'];
// check to see if identical information was already stored under active person_id
// if (in_array($year_id, $personYearArray))
// {
if ($updated == false) {
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
// just to make sure...
$updateValues['year_id'] = $year_id;
// echo "<br>update values to ".$savedPersonID." from ".$person_id.": <pre>".print_r($person_year_array2,true)."</pre><br>";
// update the person ID for a person-DG record (in database)
$personYearUpdater->loadFromArray($updateValues);
$personYearUpdater->updateDBTable();
$updated = true;
// prevents the new data from being overwritten with older data (and allows better efficiency)
$reportDataDump .= 'No record found for person ID ' . $savedPersonID . ', updating person ID for person ID ' . $person_id . $BR . $BR;
} else {
// echo "<br>TO BE DELETED FROM cim_hrdb_person_year: person_id = ".$personID.", year = ".$year_id."<br>";
$reportDataDump .= 'Deleting record for alternative person ID ' . $person_id . $BR . $BR;
$personYearUpdater->deleteEntry();
}
// else // add person-year data from other person-id-linked records
// {
// $updateValues = array();
// $updateValues['person_id'] = $savedPersonID; // just to make sure...
// $updateValues['year_id'] = $year_id;
//
// echo "<br>update values to ".$savedPersonID." from ".$person_id.": <pre>".print_r($person_year_array2,true)."</pre><br>";
//
// // update the person ID for a person-DG record (in database)
// $personYearUpdater->loadFromArray( $updateValues );
// $personYearUpdater->updateDBTable();
// }
}
next($person_year_array2);
}
// Update the Emergency Contact table (cim_hrdb_emerg)
// Step 1) Find the information stored for the active person_id
$emergInfoArray = array();
$emerg_info_manager = new RowManager_EmergencyInfoManager();
$emerg_info_manager->setPersonID($savedPersonID);
$emerg_info_manager->setSortOrder('emerg_id');
$emerg_info_manager->setAscDesc('DESC');
// sort by descending emerg IDs
// echo "<BR>".$savedPersonID.",";
$emergInfoData = $emerg_info_manager->getListIterator();
$emerg_info_array = $emergInfoData->getDataList();
reset($emerg_info_array);
foreach (array_keys($emerg_info_array) as $l) {
$record = current($emerg_info_array);
$emerg_id = $record['emerg_id'];
$emerg_info = array();
$fields = page_PersonRecordCleanUp::EMERG_RECORD_FIELDS;
$fieldsArray = explode(",", $fields);
// store the emergency info values in an array
reset($fieldsArray);
foreach (array_keys($fieldsArray) as $k) {
$fieldName = current($fieldsArray);
$emerg_info[$fieldName] = $record[$fieldName];
next($fieldsArray);
}
// $emerg_info['person_id'] = $record['person_id'];
// $emerg_info['emerg_passportNum'] = $record['emerg_passportNum'];
// $emerg_info['emerg_passportOrigin'] = $record['emerg_passportOrigin'];
// $emerg_info['emerg_passportExpiry'] = $record['emerg_passportExpiry'];
// $emerg_info['emerg_contactName'] = $record['emerg_contactName'];
// $emerg_info['emerg_contactRship'] = $record['emerg_contactRship'];
// $emerg_info['emerg_contactHome'] = $record['emerg_contactHome'];
// $emerg_info['emerg_contactWork'] = $record['emerg_contactWork'];
// $emerg_info['emerg_contactMobile'] = $record['emerg_contactMobile'];
// $emerg_info['emerg_contactEmail'] = $record['emerg_contactEmail'];
// $emerg_info['emerg_birthdate'] = $record['emerg_birthdate'];
// $emerg_info['emerg_medicalNotes'] = $record['emerg_medicalNotes'];
// store array of record values in array with emerg_id as key
$emergInfoArray[$emerg_id] = $emerg_info;
next($emerg_info_array);
}
// TEST CONDITION
// if (count($emerg_info_array) > 0)
// {
// echo "<br>Emergency info for active person_id ".$savedPersonID.": <pre>".print_r($emergInfoArray,true)."</pre><br>";
// }
$reportDataDump .= 'Changes made to <b>cim_hrdb_emerg table</b>: ' . $BR;
// remove all but the most recent emergency info record (associated with active person id)
if (count($emergInfoArray) > 1) {
reset($emergInfoArray);
$reportDataDump .= 'Saving the emergency contact record associated with person ID ' . $savedPersonID . $BR . $BR;
next($emergInfoArray);
// keep the first record (most recent emerg_id)
foreach (array_keys($emergInfoArray) as $m) {
$record = current($emergInfoArray);
$emergID = key($emergInfoArray);
// echo "REMOVE person-emerg entry for person_id = ".$savedPersonID." using key = ".key($emergInfoArray);
if (isset($emergID) && $emergID != '') {
$emergUpdater = new RowManager_EmergencyInfoManager($emergID);
$emergUpdater->deleteEntry();
$reportDataDump .= 'Deleting redundant emergency contact record having emergency ID ' . $emergID . $BR . $BR;
}
next($emergInfoArray);
}
}
// Step 2) Update the emergency contact records having the non-active person ids for this person
$emerg_info_manager2 = new RowManager_EmergencyInfoManager();
$emerg_info_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$emerg_info_manager2->setSortOrder('person_id');
$emerg_info_manager2->setAscDesc('DESC');
// sort by descending person IDs
// echo "candidate person ids = ".$person_ids_list."<br>";
$emergInfoData2 = $emerg_info_manager2->getListIterator();
$emerg_info_array2 = $emergInfoData2->getDataList();
// echo "<br>Contact data for ALL person_ids: <pre>".print_r($emerg_info_array2,true)."</pre><br>";
$updateValues = array();
// $updateValues = $this->initRecord(page_PersonRecordCleanUp::EMERG_RECORD_FIELDS);
// $updateID = -1;
// // If no record was found for the active person record - then set flag for updating
// $updated = true;
// if (count($personYearArray) < 1)
// {
// $updated = false;
// }
reset($emerg_info_array2);
foreach (array_keys($emerg_info_array2) as $l) {
$record = current($emerg_info_array2);
$personID = $record['person_id'];
$contactName = $record['emerg_contactName'];
if ($personID != $savedPersonID) {
$emerg_id = $record['emerg_id'];
$personEmergUpdater = new RowManager_EmergencyInfoManager($emerg_id);
// $personEmergUpdater->setPersonEmergID($emerg_id);
$person_id = $record['person_id'];
if (count($emergInfoArray) < 1) {
// update the last-updated record with further information (if there was a last update)
// if ($updateID != -1)
// {
// $personEmergUpdater = new RowManager_EmergencyInfoManager($updateID);
// }
// TODO: reactivate the above and then delete all entries but the first totally updated record
$record['person_id'] = $savedPersonID;
// require this to actually change person ID
// // determine if some fields have been replaced previously
// $flagArray = $this->checkRecordFields($updateValues, page_PersonRecordCleanUp::EMERG_RECORD_FIELDS);
//
// reset($flagArray);
// foreach(array_keys($flagArray) as $m)
// {
// // if field is empty in update record then
// // replace with most recent value - if one exists
// // (since we are going through a list of person ids
// // in descending order)
// $flag = current($flagArray);
// if ($flag == '0')
// {
// $fieldName = key($flagArray);
// $updateValues[$fieldName] = $record[$fieldName]; // update the array (or replace empty with empty)
// }
// next($flagArray);
// }
// (BELOW) REMOVE WHEN USING ABOVE:
$updateValues['person_id'] = $savedPersonID;
// update the person ID for an emergency contact record (in database)
$personEmergUpdater->loadFromArray($updateValues);
$personEmergUpdater->updateDBTable();
// $updateID = $emerg_id; // TODO: ensure that we end up with only ONE record that is updated with latest data
$reportDataDump .= 'No record found for person ID ' . $savedPersonID . ', updating person ID for person ID ' . $person_id . $BR . $BR;
} else {
$contact_name = $record['emerg_contactHome'];
// echo "<br>TO BE DELETED FROM cim_hrdb_emerg: person_id = ".$person_id.", contactName = ".$contact_name."<br>";
$reportDataDump .= 'Deleting record for alternative person ID ' . $person_id . ' having contact name = ' . $contactName . $BR . $BR;
$personEmergUpdater->deleteEntry();
}
}
next($emerg_info_array2);
}
/**** TODO: have code to deal with redundant person ids in 'cim_hrdb_admin' (LOW-PRIORITY DUE TO SMALL SIZE OF TABLE) **/
/*** Update the Campus Assignment table (cim_hrdb_assignment) **/
// Step 1) Find the information stored for the active person_id
$campusAssignArray = array();
$campus_assign_manager = new RowManager_AssignmentsManager();
$campus_assign_manager->setPersonID($savedPersonID);
$campus_assign_manager->setSortOrder('assignment_id');
$campus_assign_manager->setAscDesc('DESC');
// sort by descending assignment IDs
$campusAssignData = $campus_assign_manager->getListIterator();
$campus_assign_array = $campusAssignData->getDataList();
reset($campus_assign_array);
foreach (array_keys($campus_assign_array) as $id) {
$record = current($campus_assign_array);
$assign_id = $record['assignment_id'];
$assignment_info = array();
$fields = page_PersonRecordCleanUp::ASSIGNMENT_RECORD_FIELDS;
$fieldsArray = explode(",", $fields);
// store the campus assignment values in an array
reset($fieldsArray);
foreach (array_keys($fieldsArray) as $k) {
$fieldName = current($fieldsArray);
$assignment_info[$fieldName] = $record[$fieldName];
next($fieldsArray);
}
// store array of record values in array with assign_id as key
$campusAssignArray[$assign_id] = $assignment_info;
next($campus_assign_array);
}
// TEST CONDITION
// if (count($campus_assign_array) > 0)
// {
// echo "<br>Campus assignment info for active person_id ".$savedPersonID.": <pre>".print_r($campusAssignArray,true)."</pre><br>";
// }
$reportDataDump .= 'Changes made to <b>cim_hrdb_assignment table</b>: ' . $BR;
// TODO??: remove all but the most recent campus assignment record (associated with active person id)
// REMEMBER: a student may be an alumni of one school or attend two schools at once...
if (count($campusAssignArray) > 1) {
$campus_ids_list = array();
$idx = 0;
reset($campusAssignArray);
$row = current($campusAssignArray);
$campus_ids_list[$idx++] = $row['campus_id'];
next($campusAssignArray);
// keep the first record (most recent assign_id)
foreach (array_keys($campusAssignArray) as $m) {
$record = current($campusAssignArray);
$assignID = key($campusAssignArray);
// echo "REMOVE person-campus entry for person_id = ".$savedPersonID." using key = ".key($campusAssignArray);
if (isset($assignID) && $assignID != '') {
// remove entries having a campus_id already stored for the active person record
if (in_array($record['campus_id'], $campus_ids_list)) {
$assignUpdater = new RowManager_AssignmentsManager($assignID);
$assignUpdater->deleteEntry();
$reportDataDump .= 'Deleting redundant campus assignment record having campus ID ' . $record['campus_id'] . $BR . $BR;
} else {
$campus_ids_list[$idx++] = $record['campus_id'];
}
}
next($campusAssignArray);
}
}
// Step 2) Update the campus assignment records having the non-active person ids for this person
$campus_assign_manager2 = new RowManager_AssignmentsManager();
$campus_assign_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$campus_assign_manager2->setSortOrder('person_id');
$campus_assign_manager2->setAscDesc('DESC');
// sort by descending person IDs
// echo "candidate person ids = ".$person_ids_list."<br>";
$campusAssignData2 = $campus_assign_manager2->getListIterator();
$campus_assign_array2 = $campusAssignData2->getDataList();
// echo "<br>Contact data for ALL person_ids: <pre>".print_r($emerg_info_array2,true)."</pre><br>";
$campusIDs = array();
$idx = 0;
reset($campus_assign_array2);
foreach (array_keys($campus_assign_array2) as $l) {
$record = current($campus_assign_array2);
$personID = $record['person_id'];
if ($personID != $savedPersonID) {
// echo "FOUND person ".$personID;
$assignment_id = $record['assignment_id'];
$campus_id = $record['campus_id'];
$personAssignmentUpdater = new RowManager_AssignmentsManager($assignment_id);
// $personEmergUpdater->setPersonEmergID($emerg_id);
$person_id = $record['person_id'];
if (count($campusAssignArray) < 1) {
$record['person_id'] = $savedPersonID;
// require this to actually change person ID
// only create a new record with active person id if the campus ID not associated with the person yet
if (!in_array($campus_id, $campusIDs)) {
// update the person ID for an campus assignment record (in database)
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
$personAssignmentUpdater->loadFromArray($updateValues);
$personAssignmentUpdater->updateDBTable();
$reportDataDump .= 'No record found for person ID ' . $savedPersonID . ' (with campus ID ' . $campus_id . '),<br>';
$reportDataDump .= 'updating person ID for person ID ' . $person_id . $BR . $BR;
$campusIDs[$idx++] = $campus_id;
} else {
// echo "<br>Delete op #1.";
$personAssignmentUpdater->deleteEntry();
$reportDataDump .= 'Deleting record for alternative person ID ' . $person_id . $BR . $BR;
}
} else {
// echo "<br>TO BE DELETED FROM cim_hrdb_emerg: person_id = ".$person_id.", campus_id = ".$campus_id."<br>";
$personAssignmentUpdater->deleteEntry();
$reportDataDump .= 'Deleting record for alternative person ID ' . $person_id . $BR . $BR;
}
}
next($campus_assign_array2);
}
/*** Update the Registrations table (cim_reg_registration) **/
/** NOTE: Currenlty only use step 2, which simply replace associated person IDs with active person ID **/
// Step 1) Find the information stored for the active person_id
// $regRecordsArray = array();
// $idx = 0;
//
// $registration_manager = new RowManager_RegistrationManager();
// $registration_manager->setPersonID($savedPersonID);
// $registration_manager->setSortOrder( 'registration_id' );
// $registration_manager->setAscDesc( 'DESC' ); // sort by descending registration IDs
//
// // echo "<BR>".$savedPersonID.",";
// $registrationData = $registration_manager->getListIterator();
// $regs_array = $registrationData->getDataList();
// reset($regs_array);
// foreach(array_keys($regs_array) as $id)
// {
// $record = current($regs_array);
//
// $reg_id = $record['registration_id'];
// // $registration_info = array();
//
// // $fields = page_PersonRecordCleanUp::REGISTRATION_RECORD_FIELDS;
// // $fieldsArray = explode(",",$fields);
// //
// // // store the campus assignment values in an array
// // reset($fieldsArray);
// // foreach(array_keys($fieldsArray) as $k)
// // {
// // $fieldName = current($fieldsArray);
// //
// // $registration_info[$fieldName] = $record[$fieldName];
// //
// // next($fieldsArray);
// // }
//
// // store array of record values in array with assign_id as key
// // $regRecordsArray[$reg_id] = $registration_info;
// $regRecordsArray[$idx++] = $reg_id;
//
// next($regs_array);
// }
//
// // TEST CONDITION
// if (count($regs_array) > 0)
// {
// echo "<br>Registration ids for active person_id ".$savedPersonID.": <pre>".print_r($regRecordsArray,true)."</pre><br>";
// }
// TODO??: convert the code below to delete registration records that appear under same person_id (obviously with same event_id)
// if (count($regRecordsArray) > 1) // remove ONLY records with redundant person-campus pairs
// {
// $campus_ids_list = array();
// $idx = 0;
// reset($campusAssignArray);
// $row = current($campusAssignArray);
// $campus_ids_list[$idx++] = $row['campus_id'];
// next($campusAssignArray); // keep the first record (most recent emerg_id)
//
// foreach(array_keys($campusAssignArray) as $m)
// {
// $record = current($campusAssignArray);
//
// $assignID = key($campusAssignArray);
//
// // echo "REMOVE person-campus entry for person_id = ".$savedPersonID." using key = ".key($campusAssignArray);
// if ((isset($assignID))&&($assignID != ''))
// {
// // remove entries having a campus_id already stored for the active person record
// if (in_array($record['campus_id'], $campus_ids_list))
// {
// $assignUpdater = new RowManager_AssignmentsManager($assignID);
// $assignUpdater->deleteEntry();
// }
// else // store campus_id so as to remove any other records with this campus_id
// {
// $campus_ids_list[$idx++] = $record['campus_id'];
// }
// }
//
// next($campusAssignArray);
// }
//
// }
$reportDataDump .= 'Changes made to <b>cim_reg_registration table</b>: ' . $BR;
// Step 2) Update the registration records having the non-active person ids for this person (TODO: work from here)
$registration_manager2 = new RowManager_RegistrationManager();
$registration_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$registration_manager2->setSortOrder('person_id');
$registration_manager2->setAscDesc('DESC');
// sort by descending person IDs
// echo "candidate person ids = ".$person_ids_list."<br>";
$registrationData2 = $registration_manager2->getListIterator();
$registration_array2 = $registrationData2->getDataList();
// echo "<br>Contact data for ALL person_ids: <pre>".print_r($emerg_info_array2,true)."</pre><br>";
// $eventIDs = array();
// $idx = 0;
reset($registration_array2);
foreach (array_keys($registration_array2) as $key) {
$record = current($registration_array2);
$personID = $record['person_id'];
if ($personID != $savedPersonID) {
// echo "FOUND person ".$personID;
$registration_id = $record['registration_id'];
// $event_id = $record['event_id'];
$regRecordUpdater = new RowManager_RegistrationManager($registration_id);
// $personEmergUpdater->setPersonEmergID($emerg_id);
// if (count($regRecordsArray) < 1) // if active person ID doesn't have record yet, then update older record with active person ID
// {
// $record['person_id'] = $savedPersonID; // require this to actually change person ID
// // only create a new record with active person id if the event_id not associated with the person yet
// if (!in_array($event_id, $eventIDs))
// {
// update the person ID for an campus assignment record (in database)
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
$regRecordUpdater->loadFromArray($updateValues);
$regRecordUpdater->updateDBTable();
$reportDataDump .= 'Found registration record for alternative ID of person ID ' . $savedPersonID . ',' . $BR;
$reportDataDump .= 'updating person ID for person ID ' . $personID . $BR . $BR;
// $eventIDs[$idx++] = $event_id;
// }
// else
// {
// echo "<br>Delete op #1.";
// $regRecordUpdater->deleteEntry();
// }
// }
// else
// {
// echo "<br>TO BE DELETED FROM cim_reg_registration: person_id = ".$personID.", event_id = ".$event_id."<br>";
// $regRecordUpdater->deleteEntry();
// }
}
next($registration_array2);
}
/*** Update the Staff table (cim_hrdb_staff) **/
// Step 1) Find the information stored for the active person_id
$staff_manager = new RowManager_StaffManager();
$staff_manager->setPersonID($savedPersonID);
$staff_manager->setSortOrder('staff_id');
$staff_manager->setAscDesc('DESC');
// sort by descending assignment IDs
// echo "<BR>".$savedPersonID.",";
$staffData = $staff_manager->getListIterator();
$staff_array = $staffData->getDataList();
// reset($staff_array);
// foreach(array_keys($staff_array) as $id)
// {
// $record = current($staff_array);
//
// $staff_id = $record['staff_id'];
// $staffRecordsArray[$idx++] = $staff_id;
//
// next($staff_array);
// }
// TEST CONDITION
// if (count($staff_array) > 0)
// {
// echo "<br>Staff info for active person_id ".$savedPersonID.": <pre>".print_r($staff_array,true)."</pre><br>";
// }
$reportDataDump .= 'Changes made to <b>cim_hrdb_staff table</b>: ' . $BR;
// Step 2) Remove all but one of the staff records
if (count($staff_array) > 1) {
reset($staff_array);
next($staff_array);
// keep the first record (most recent staff_id for active person)
$reportDataDump .= 'Saving the first staff record associated with person ID ' . $savedPersonID . $BR . $BR;
// echo 'staff array = <pre>'.print_r($staff_array,true).'</pre>';
foreach (array_keys($staff_array) as $m) {
$record = current($staff_array);
$staffID = key($staff_array);
// remove redundant entry
$staffUpdater = new RowManager_StaffManager($staffID);
$staffUpdater->deleteEntry();
$reportDataDump .= 'Deleting redundant staff record having staff ID ' . $staffID . $BR . $BR;
$id = next($staff_array);
// staff ID
if ($id === FALSE) {
break;
// no valid data found so break out of the loop
}
}
}
// Step 3) Delete the staff records having the non-active person ids for this person
$staff_manager2 = new RowManager_StaffManager();
$staff_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$staff_manager2->setSortOrder('person_id');
$staff_manager2->setAscDesc('DESC');
// sort by descending person IDs
$staffData2 = $staff_manager2->getListIterator();
$staff_array2 = $staffData2->getDataList();
$toUpdate = false;
if (count($staff_array) < 1) {
$toUpdate = true;
}
reset($staff_array2);
foreach (array_keys($staff_array2) as $l) {
$record = current($staff_array2);
$personID = $record['person_id'];
if ($personID != $savedPersonID) {
$staff_id = $record['staff_id'];
$staffUpdater = new RowManager_StaffManager($staff_id);
if ($toUpdate == true) {
// $record['person_id'] = $savedPersonID; // require this to actually change person ID
// update the person ID for a staff record (in database)
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
$staffUpdater->loadFromArray($updateValues);
$staffUpdater->updateDBTable();
$toUpdate = false;
$reportDataDump .= 'No record found for person ID ' . $savedPersonID . ', updating person ID for person ID ' . $personID . $BR . $BR;
} else {
// echo "<br>TO BE DELETED FROM cim_hrdb_staff: person_id = ".$person_id.", staff_id = ".$staff_id."<br>";
$staffUpdater->deleteEntry();
$reportDataDump .= 'Deleting record for alternative person ID ' . $personID . $BR . $BR;
}
}
next($staff_array2);
}
/***** Remove redundant sub-group associations, otherwise rename person-id to active person-id ******************/
// Update the Person-DG table (sch_person_sub_group): still requires clean up
// Step 1) Find the information stored for the active person_id
$dg_campus_array = array();
$person_dg_manager = new RowManager_PersonDGManager();
$person_dg_manager->setPersonID($savedPersonID);
$person_dg_manager->setSortOrder('person_sub_group_id');
$person_dg_manager->setAscDesc('DESC');
// sort by descending person_sub_group_IDs
$personDGData = $person_dg_manager->getListIterator();
$personDGArray = $personDGData->getDataList();
reset($personDGArray);
foreach (array_keys($personDGArray) as $l) {
$record = current($personDGArray);
$dg_id = $record['sub_group_id'];
$campus_id = $record['organization_id'];
$dg_campus_array[$dg_id] = $campus_id;
next($personDGArray);
}
//
// if (count($dg_campus_array) > 0)
// {
// echo "<br>DG for active person_id ".$savedPersonID.": <pre>".print_r($personDGArray,true)."</pre><br>";
// // echo "<br>DG-Campus for active person_id ".$savedPersonID.": <pre>".print_r($dg_campus_array,true)."</pre><br>";
// }
$reportDataDump .= 'Changes made to <b>sch_person_sub_group table</b>: ' . $BR;
// Step 2) Update the records having the non-active person ids for this person
$person_dg_manager2 = new RowManager_PersonDGManager();
$person_dg_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$person_dg_manager2->setSortOrder('person_id');
$person_dg_manager2->setAscDesc('DESC');
// sort by descending person IDs
$personDGData2 = $person_dg_manager2->getListIterator();
$personDGArray2 = $personDGData2->getDataList();
// If no record was found for the active person record - then set flag for updating
// $updated = true;
// if (count($personDGArray2) < 1)
// {
// $updated = false;
// }
// $j = 0;
// echo 'DG array results = <pre>'.print_r($personDGArray2,true).'</pre>';
// echo 'dg - campus array: <pre>'.print_r($dg_campus_array,true).'</pre>';
reset($personDGArray2);
foreach (array_keys($personDGArray2) as $l) {
$record = current($personDGArray2);
$personID = $record['person_id'];
if ($personID != $savedPersonID) {
$personSubGroupID = $record['person_sub_group_id'];
$personDGUpdater = new RowManager_PersonDGManager($personSubGroupID);
$dg_id = $record['sub_group_id'];
$campus_id = $record['organization_id'];
// echo 'dg-id, campus-id = '.$dg_id.', '.$campus_id.'<br>';
// check to see if identical information was already stored under active person_id
if (isset($dg_campus_array[$dg_id]) && $dg_campus_array[$dg_id] == $campus_id) {
$personDGUpdater->deleteEntry();
$reportDataDump .= 'Deleting record for alternative person ID ' . $personID . $BR;
$reportDataDump .= 'since it has information already stored for primary person ID ' . $savedPersonID . $BR . $BR;
// echo "<br>TO BE DELETED FROM sch_person_sub_group: person_id = ".$personID.", dg = ".$dg_id.", campus = ".$campus_id."<br>";
} else {
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
// just to make sure...
$updateValues['sub_group_id'] = $record['sub_group_id'];
$updateValues['organization_id'] = $record['organization_id'];
// echo "<br>update values from ".$personID.": <pre>".print_r($dg_campus_array,true)."</pre><br>";
// TODO: deal with case where two non-active person-ids contain identical info (currently both are saved with active person id)
// update the person ID for a person-DG record (in database)
$personDGUpdater->loadFromArray($updateValues);
$personDGUpdater->updateDBTable();
$reportDataDump .= 'Updating record for alternative person ID ' . $personID . $BR;
$reportDataDump .= 'since it has new information: setting person ID to be ' . $savedPersonID . $BR . $BR;
}
}
next($personDGArray2);
}
/*** Update the personal schedule table (sch_schedule) **/
// Step 1) Find the information stored for the active person_id
$schedule_array = array();
$schedule_manager = new RowManager_ScheduleManager();
$schedule_manager->setPersonID($savedPersonID);
$schedule_manager->setSortOrder('schedule_id');
$schedule_manager->setAscDesc('DESC');
// sort by descending schedule_IDs
$personScheduleData = $schedule_manager->getListIterator();
$personScheduleArray = $personScheduleData->getDataList();
reset($personScheduleArray);
$idx = 0;
foreach (array_keys($personScheduleArray) as $l) {
$record = current($personScheduleArray);
$schedule_block = $record['schedule_block'];
$schedule_array[$idx] = $schedule_block;
next($personScheduleArray);
$idx++;
}
// echo 'active person schedule = <pre>'.print_r($personScheduleArray,true).'</pre>';
// echo 'person blocks array = <pre>'.print_r($schedule_array,true).'</pre>';
$reportDataDump .= 'Changes made to <b>sch_schedule table</b>: ' . $BR;
// Step 2) Create new records for active person ID from data linked to the non-active person ids for this person
$schedules = new RowManager_ScheduleManager();
$schedule_manager2 = new MultiTableManager();
$schedule_manager2->addRowManager($schedules);
$schedule_manager2->addSearchCondition('person_id in (' . $person_ids_list . ')');
$schedule_manager2->addSortField('person_id', 'DESC');
// $schedule_manager2->setAscDesc( 'DESC' ); // sort by descending person ID
$personScheduleData2 = $schedule_manager2->getListIterator();
$personScheduleArray2 = $personScheduleData2->getDataList();
// echo 'other person-ids schedule array = <pre>'.print_r($personScheduleArray2,true).'</pre>';
$toUpdate = false;
if (count($schedule_array) < 1) {
$toUpdate = true;
// echo 'Staff update needed';
}
// echo 'schedule array = <pre>'.print_r($personScheduleArray2,true).'</pre>';
$updatePersonID = -1;
reset($personScheduleArray2);
foreach (array_keys($personScheduleArray2) as $l) {
$record = current($personScheduleArray2);
$personID = $record['person_id'];
if ($personID != $savedPersonID) {
$found_sch_block = $record['schedule_block'];
$schedule_id = $record['schedule_id'];
$personScheduleUpdater = new RowManager_ScheduleManager($schedule_id);
// $personScheduleUpdater->setPersonID($personID);
// $personScheduleUpdater->setScheduleBlock($found_sch_block);
// if the active person_id DOES NOT HAVE this schedule block, then update record with active person id
// if (!in_array($found_sch_block, $schedule_array)) // COMMENTED OUT BECAUSE WE DON'T WANT TO MERGE SCHEDULES
// {
// if the active person_id DOES NOT HAVE **ANY** schedule block, then update record with active person id
if ($toUpdate == true || $updatePersonID == $personID) {
$updateValues = array();
$updateValues['person_id'] = $savedPersonID;
// NEW VALUE
$updateValues['schedule_block'] = $found_sch_block;
// just to make sure...
// update the person ID for a person-DG record (in database)
$personScheduleUpdater->loadFromArray($updateValues);
$personScheduleUpdater->updateDBTable();
if ($toUpdate == true) {
$toUpdate = false;
$updatePersonID = $personID;
// set person ID whose schedule blocks to use for updating
$reportDataDump .= 'No schedule block found for person ID ' . $savedPersonID . ',' . $BR;
$reportDataDump .= 'updating using schedule blocks from person ID ' . $updatePersonID . $BR . $BR;
}
} else {
// TODO: enable this code at mid-April 2008
// $personScheduleUpdater->deleteEntry();
// $reportDataDump .= 'Deleting record for alternative person ID '.$personID.$BR.$BR;
// TODO: deal with case where two non-active person-ids contain identical info
// (currently both are saved with active person id)
}
}
next($personScheduleArray2);
}
/*** Remove all person records other than the active person ID (most often the one used in most-recent login) ***/
$personIDs = explode(',', $person_ids_list);
foreach (array_values($personIDs) as $personID) {
if ($personID != $savedPersonID) {
$personUpdater = new RowManager_PersonManager($personID);
$personUpdater->deleteEntry();
$reportDataDump .= 'Deleting redundant <b>cim_hrdb_person</b> record having person ID ' . $personID . $BR;
}
next($personIDs);
}
}
// end if (isset($indivDataArray))
$reportDataDump = substr($reportDataDump, 0, -4);
// remove the last <BR>
$reportDataDump .= $HR;
next($personDataArray);
}
$this->template->set('reportDataDump', $reportDataDump);
// store the Row Manager's XML Node Name
// $this->template->set( 'rowManagerXMLNodeName', RowManager_ReceiptManager::XML_NODE_NAME );
// store the primary key field name for the data being displayed
// $this->template->set( 'primaryKeyFieldName', 'ccreceipt_sequencenum');
/*
* Set up any additional data transfer to the Template here...
*/
$templateName = 'page_PersonRecordCleanUp.tpl.php';
// if you are creating a custom template for this page then
// replace $templateName with the following:
//$templateName = 'page_DisplayCCtransactionReceipt.php';
// send CC transaction confirmation e-mail (but first remove links)
// $link_regex = '{<a.*?</a>}';
// $message_body = $this->template->fetch( $templateName );
// $message_body = preg_replace( $link_regex, '', $message_body);
//
// if (!defined('IGNORE_EMAILS'))
// {
// $this->sendCCTransactionEmail($message_body);
// }
return $this->template->fetch($templateName);
}