PHP error::log_error方法代码示例

 /**
  * Function to support the services/data_cleaner/verify web-service. 
  * Receives a list of proposed records and applies verification rules to them, then
  * returns a list of verification notices.
  * Input is provided in the $_GET or $_POST data sent to the method as follows:
  * auth_token - read authorisation token
  * nonce - read nonce
  * sample - Provides details of the sample being verified. If verifying a list
  * of records from different places or dates then the sample entry can be ommitted or only partially
  * filled-in with the missing information provided on a record by record bases. A JSON formatted
  * object with entries for sample:survey_id, sample:date, sample:entered_sref and sample:entered_sref_system, plus 
  * optional sample:geom (WKT format).
  * occurrences - JSON format, provide an array of the occurrence record to verify. Each record is an object
  * with occurrence:taxa_taxon_list_id, an optional stage plus any of the values for the sample which need to be 
  * specified on a record by record bases. I.e. provide sample:date if the sample information sent
  * does not include a date, or a date is included but this record is for a different date.
  * rule_types - JSON formatted array of the rule types to run. If not provided, then all rule types are run.
  * E.g. ["WithoutPolygon","PeriodWithinYear"] to run just without polygon and period within year checks.
  * @return JSON A JSON array containing a list of notifications. Each notification is a JSON
  * object, with taxa_taxon_list_id and message properties.
  */
 public function verify()
 {
     // authenticate requesting website for this service
     $this->authenticate('read');
     if (isset($_REQUEST['sample'])) {
         $sample = json_decode($_REQUEST['sample'], true);
     }
     if (isset($_REQUEST['occurrences'])) {
         $occurrences = json_decode($_REQUEST['occurrences'], true);
     }
     if (empty($sample) || empty($occurrences)) {
         $this->response = 'Invalid parameters';
     } else {
         $db = new Database();
         // Create an empty template table
         $db->query("select * into temporary occdelta from cache_occurrences limit 0;");
         try {
             $this->prepareOccdelta($db, $sample, $occurrences);
             $r = $this->runRules($db);
             $db->query('drop table occdelta');
             $this->content_type = 'Content-Type: application/json';
             $this->response = json_encode($r);
         } catch (Exception $e) {
             $db->query('drop table occdelta');
             $this->response = "Query failed";
             error::log_error('Error occurred calling verification rule service', $e);
         }
     }
     $this->send_response();
 }

 /**
  * Provides the services/data_utils/bulk_verify service. This takes a report plus params (json object) in the $_POST
  * data and verifies all the records returned by the report according to the filter. Pass ignore=true to allow this to 
  * ignore any verification check rule failures (use with care!).
  */
 public function bulk_verify()
 {
     $db = new Database();
     $this->authenticate('write');
     $report = $_POST['report'];
     $params = json_decode($_POST['params'], true);
     $params['sharing'] = 'verification';
     $websites = $this->website_id ? array($this->website_id) : null;
     $this->reportEngine = new ReportEngine($websites, $this->user_id);
     try {
         // Load the report used for the verification grid with the same params
         $data = $this->reportEngine->requestReport("{$report}.xml", 'local', 'xml', $params);
         // now get a list of all the occurrence ids
         $ids = array();
         foreach ($data['content']['records'] as $record) {
             if ($record['record_status'] !== 'V' && (!empty($record['pass']) || $_POST['ignore'] === 'true')) {
                 $ids[$record['occurrence_id']] = $record['occurrence_id'];
                 $db->insert('occurrence_comments', array('occurrence_id' => $record['occurrence_id'], 'comment' => 'This record is assumed to be correct', 'created_by_id' => $this->user_id, 'created_on' => date('Y-m-d H:i:s'), 'updated_by_id' => $this->user_id, 'updated_on' => date('Y-m-d H:i:s')));
             }
         }
         $db->from('occurrences')->set(array('record_status' => 'V', 'verified_by_id' => $this->user_id, 'verified_on' => date('Y-m-d H:i:s'), 'updated_by_id' => $this->user_id, 'updated_on' => date('Y-m-d H:i:s')))->in('id', array_keys($ids))->update();
         echo count($ids);
         $db->from('cache_occurrences')->set(array('record_status' => 'V', 'cache_updated_on' => date('Y-m-d H:i:s')))->in('id', array_keys($ids))->update();
     } catch (Exception $e) {
         echo $e->getMessage();
         error::log_error('Exception during bulk verify', $e);
     }
 }

 /**
  * Convert PHP errors to exceptions so that they can be handled nicely.
  */
 public static function indicia_error_handler($errno, $errstr, $errfile, $errline)
 {
     // if error reporting has been switched off completely we don't want to convert the error to an exception
     // should really do a binary AND between error_reporting() and $errno; which would only raise exceptions for those which are
     // flagged by error_reporting(), but this may impact unknown assumptions elsewhere.
     if (error_reporting() == 0) {
         return true;
     }
     try {
         throw new ErrorException($errstr, $errno, 0, $errfile, $errline);
     } catch (Exception $e) {
         error::log_error('Error converted to exception', $e);
         throw $e;
     }
 }

 /**
  * Performs the actual task of table population.
  */
 public static function populate_cache_table($db, $table, $last_run_date)
 {
     $queries = kohana::config("cache_builder.{$table}");
     try {
         $count = cache_builder::get_changelist($db, $table, $queries, $last_run_date);
         if ($count > 0) {
             cache_builder::do_delete($db, $table, $queries);
             // preprocess some of the tags in the queries
             if (is_array($queries['update'])) {
                 foreach ($queries['update'] as $key => &$sql) {
                     $sql = str_replace('#join_needs_update#', $queries['join_needs_update'], $sql);
                 }
             } else {
                 $queries['update'] = str_replace('#join_needs_update#', $queries['join_needs_update'], $queries['update']);
             }
             cache_builder::run_statement($db, $table, $queries['update'], 'update');
             // preprocess some of the tags in the queries
             if (is_array($queries['insert'])) {
                 foreach ($queries['insert'] as $key => &$sql) {
                     $sql = str_replace('#join_needs_update#', $queries['join_needs_update'] . ' and (nu.deleted=false or nu.deleted is null)', $sql);
                 }
             } else {
                 $queries['insert'] = str_replace('#join_needs_update#', $queries['join_needs_update'] . ' and (nu.deleted=false or nu.deleted is null)', $queries['insert']);
             }
             cache_builder::run_statement($db, $table, $queries['insert'], 'insert');
             if (isset($queries['extra_multi_record_updates'])) {
                 cache_builder::run_statement($db, $table, $queries['extra_multi_record_updates'], 'final update');
             }
             if (!variable::get("populated-{$table}")) {
                 $cacheQuery = $db->query("select count(*) from cache_{$table}")->result_array(false);
                 if (isset($queries['count'])) {
                     $totalQuery = $db->query($queries['count'])->result_array(false);
                 } else {
                     $totalQuery = $db->query("select count(*) from {$table} where deleted='f'")->result_array(false);
                 }
                 $percent = round($cacheQuery[0]['count'] * 100 / $totalQuery[0]['count']);
                 echo "{$table} population in progress - {$percent}% done";
             }
             echo '<br/>';
         }
         $db->query("drop table needs_update_{$table}");
     } catch (Exception $e) {
         error::log_error('Building cache', $e);
         echo $e->getMessage();
         $db->query("drop table needs_update_{$table}");
     }
 }

 private static function populate_summary_table_for_survey($db, $last_run_date, $definition, $missing_check)
 {
     $YearTaxonLocationUser = array();
     $YearTaxonLocation = array();
     $YearTaxonUser = array();
     $YearTaxon = array();
     try {
         $count = summary_builder::get_changelist($db, $last_run_date, $definition, $YearTaxonLocationUser, $YearTaxonLocation, $YearTaxonUser, $YearTaxon, $missing_check);
         if ($count > 0) {
             summary_builder::do_summary($db, $definition, $YearTaxonLocationUser, $YearTaxonLocation, $YearTaxonUser, $YearTaxon);
         }
     } catch (Exception $e) {
         error::log_error('Building summary', $e);
         echo $e->getMessage();
     }
     return;
 }

/** 
 * Postprocessing for building a geom from the list of grid squares to make an SQL based check easy
 */
function data_cleaner_without_polygon_data_cleaner_postprocess($id, $db)
{
    $db->query('create temporary table geoms_without_polygon (geom geometry)');
    try {
        $r = $db->select('key, header_name')->from('verification_rule_data')->where('verification_rule_id', $id)->in('header_name', array('10km_GB', '10km_Ireland', '1km_GB', '1km_Ireland', '10km_CI', '1km_CI'))->get()->result();
        $wktList = array();
        foreach ($r as $gridSquare) {
            switch ($gridSquare->header_name) {
                case '10km_GB':
                case '1km_GB':
                    $system = 'osgb';
                    break;
                case '10km_Ireland':
                case '1km_Ireland':
                    $system = 'osie';
                    break;
                case '10km_CI':
                case '1km_CI':
                    $system = 'utm30ed50';
                    break;
                default:
                    continue;
                    // we don't know this grid square type - should not have come back from the query
            }
            $srid = kohana::config('sref_notations.internal_srid');
            try {
                $wktList[] = "(st_geomfromtext('" . spatial_ref::sref_to_internal_wkt($gridSquare->key, $system) . "', {$srid}))";
            } catch (Exception $e) {
                kohana::debug('alert', 'Did not import grid square ' . $gridSquare->key . " for rule {$id}");
                error::log_error('Importing without polygon rules', $e);
            }
        }
        if (!empty($wktList)) {
            $db->query("insert into geoms_without_polygon values " . implode(',', $wktList));
        }
        $date = date("Ymd H:i:s");
        $uid = $_SESSION['auth_user']->id;
        $db->query("delete from verification_rule_data where verification_rule_id={$id} and header_name='geom'");
        $db->query('insert into verification_rule_data (verification_rule_id, header_name, data_group, key, value, value_geom, created_on, created_by_id, updated_on, updated_by_id) ' . "select {$id}, 'geom', 1, 'geom', '-', st_union(geom), '{$date}', {$uid}, '{$date}', {$uid} from geoms_without_polygon");
        $db->query('drop table geoms_without_polygon');
    } catch (Exception $e) {
        $db->query('drop table geoms_without_polygon');
        throw $e;
    }
}

 /**
  * Controller action called when Save clicked. Perform the import when text has been pasted into the import text area.
  */
 public function save()
 {
     $surveyId = $_POST['survey_id'];
     $survey = $this->db->select('website_id, title')->from('surveys')->where(array('id' => $surveyId))->get()->result_array(FALSE);
     $this->website_id = $survey[0]['website_id'];
     if (empty($_POST['import_survey_structure'])) {
         $this->template->title = 'Error during survey structure import';
         $this->view = new View('templates/error_message');
         $this->view->message = 'Please ensure you copy the details of a survey\'s attributes into the "Import survey structure" box before importing.';
         $this->template->content = $this->view;
     } else {
         // start a transaction
         $this->db->query('BEGIN;');
         try {
             $importData = json_decode($_POST['import_survey_structure'], true);
             $this->doImport($importData);
             $this->template->title = 'Import Complete';
             $this->view = new View('survey_structure_export/import_complete');
             $this->view->log = $this->log;
             $this->template->content = $this->view;
             $this->db->query('COMMIT;');
         } catch (Exception $e) {
             $this->db->query('ROLLBACK;');
             error::log_error('Exception during survey structure import', $e);
             $this->template->title = 'Error during survey structure import';
             $this->view = new View('templates/error_message');
             $this->view->message = 'An error occurred during the survey structure import and no changes have been made to the database. ' . 'Please make sure the import data is valid. More information can be found in the warehouse logs.';
             $this->template->content = $this->view;
         }
     }
     $this->surveyTitle = $survey[0]['title'];
     $this->page_breadcrumbs[] = html::anchor('survey', 'Surveys');
     $this->page_breadcrumbs[] = html::anchor('survey/edit/' . $surveyId, $this->surveyTitle);
     $this->page_breadcrumbs[] = $this->template->title;
 }

 /**
  * After submitting a user record, we also need to preserve the users_websites settings if the
  * submission came from the warehouse form which lets the users_websites be set up from the same
  * submission. If this is the case, the users_websites data will be stored in $this->droppedFields
  * since it is not part of the main user submission.
  */
 public function postSubmit($isInsert)
 {
     if (count($this->droppedFields) > 0) {
         try {
             $websites = ORM::factory('website')->in_allowed_websites()->find_all();
             foreach ($websites as $website) {
                 $users_websites = ORM::factory('users_website', array('user_id' => $this->id, 'website_id' => $website->id));
                 $save_array = array('id' => $users_websites->object_name, 'fields' => array('user_id' => array('value' => $this->id), 'website_id' => array('value' => $website->id)), 'fkFields' => array(), 'superModels' => array());
                 if ($users_websites->loaded || is_numeric($this->droppedFields['website_' . $website->id]['value'])) {
                     // If this is an existing users_websites record, preserve the id.
                     if ($users_websites->loaded) {
                         $save_array['fields']['id'] = array('value' => $users_websites->id);
                     }
                     $save_array['fields']['site_role_id'] = array('value' => is_numeric($this->droppedFields['website_' . $website->id]['value']) ? $this->droppedFields['website_' . $website->id]['value'] : null);
                     $users_websites->submission = $save_array;
                     $users_websites->submit();
                 }
             }
         } catch (Exception $e) {
             $this->errors['general'] = '<strong>An error occurred</strong><br/>' . $e->getMessage();
             error::log_error('Exception during postSubmit in user model.', $e);
             return false;
         }
     }
     return true;
 }

 /**
  * Adds a new relationship to between this model and another.
  *
  * @param   object   related ORM model
  * @return  boolean
  */
 public function add(ORM $model)
 {
     if ($this->has($model)) {
         return TRUE;
     }
     // Get the faked column name
     $column = $model->object_plural;
     // Add the new relation to the update
     $this->changed_relations[$column][] = $model->primary_key_value;
     try {
         throw new exception();
     } catch (Exception $e) {
         error::log_error('trace', $e);
     }
     if (isset($this->related[$column])) {
         // Force a reload of the relationships
         unset($this->related[$column]);
     }
     return TRUE;
 }

//.........这里部分代码省略.........
                     return false;
                 }
             } else {
                 $attrValueModel->date_start_value = null;
                 $attrValueModel->date_end_value = null;
                 $attrValueModel->date_type_value = null;
             }
             break;
         case 'G':
             $vf = 'geom_value';
             break;
         case 'B':
             // Boolean
             $vf = 'int_value';
             if (!empty($value)) {
                 $lower = strtolower($value);
                 if ($lower == 'false' || $lower == 'f' || $lower == 'no' || $lower == 'n' || $lower == 'off') {
                     $value = 0;
                 } elseif ($lower == 'true' || $lower == 't' || $lower == 'yes' || $lower == 'y' || $lower == 'on') {
                     $value = 1;
                 }
             }
             break;
         case 'L':
             // Lookup list
             $vf = 'int_value';
             if (!empty($value) && $fk) {
                 // value must be looked up
                 $r = $this->fkLookup(array('fkTable' => 'lookup_term', 'fkSearchField' => 'term', 'fkSearchValue' => $value, 'fkSearchFilterField' => 'termlist_id', 'fkSearchFilterValue' => $attrDef->termlist_id));
                 if ($r) {
                     $value = $r;
                 } else {
                     $this->errors[$fieldId] = "Invalid value {$value} for attribute " . $attrDef->caption;
                     kohana::log('debug', "Could not accept value {$value} into field {$vf}  for attribute {$fieldId}.");
                     return false;
                 }
             }
             break;
         default:
             // Integer
             $vf = 'int_value';
             break;
     }
     if ($vf != null) {
         $attrValueModel->{$vf} = $value;
         // Test that ORM accepted the new value - it will reject if the wrong data type for example.
         // Use a string compare to get a proper test but with type tolerance.
         // A wkt geometry gets translated to a proper geom so this will look different - just check it is not empty.
         // A float may loose precision or trailing 0 - just check for small percentage difference
         if (strcmp($attrValueModel->{$vf}, $value) === 0 || $dataType === 'G' && !empty($attrValueModel->{$vf})) {
             kohana::log('debug', "Accepted value {$value} into field {$vf} for attribute {$fieldId}.");
         } else {
             if ($dataType === 'F' && abs($attrValueModel->{$vf} - $value) < 1.0E-5 * $attrValueModel->{$vf}) {
                 kohana::log('alert', "Lost precision accepting value {$value} into field {$vf} for attribute {$fieldId}. Value=" . $attrValueModel->{$vf});
             } else {
                 $this->errors[$fieldId] = "Invalid value {$value} for attribute " . $attrDef->caption;
                 kohana::log('debug', "Could not accept value {$value} into field {$vf} for attribute {$fieldId}.");
                 return false;
             }
         }
     }
     // set metadata
     $exactMatches = array_intersect_assoc($oldValues, $attrValueModel->as_array());
     // which fields do we have in the submission?
     $fieldsWithValuesInSubmission = array_intersect_key($oldValues, $attrValueModel->as_array());
     // Hook to the owning entity (the sample, location, taxa_taxon_list or occurrence)
     $thisFk = $this->object_name . '_id';
     $attrValueModel->{$thisFk} = $this->id;
     // and hook to the attribute
     $attrFk = $this->object_name . '_attribute_id';
     $attrValueModel->{$attrFk} = $attrId;
     // we'll update metadata only if at least one of the fields have changed
     $wantToUpdateAttrMetadata = count($exactMatches) !== count($fieldsWithValuesInSubmission);
     if (!$wantToUpdateAttrMetadata) {
         $attrValueModel->wantToUpdateMetadata = false;
     }
     try {
         $v = $attrValueModel->validate(new Validation($attrValueModel->as_array()), true);
     } catch (Exception $e) {
         $v = false;
         $this->errors[$fieldId] = $e->getMessage();
         error::log_error('Exception during validation', $e);
     }
     if (!$v) {
         foreach ($attrValueModel->errors as $key => $value) {
             // concatenate the errors if more than one per field.
             $this->errors[$fieldId] = array_key_exists($fieldId, $this->errors) ? $this->errors[$fieldId] . '  ' . $value : $value;
         }
         return false;
     }
     $attrValueModel->save();
     if ($wantToUpdateAttrMetadata && !$this->wantToUpdateMetadata) {
         // we didn't update the parent's metadata. But a custom attribute value has changed, so it makes sense to update it now.
         $this->wantToUpdateMetadata = true;
         $this->set_metadata();
         $this->validate(new Validation($this->as_array()), true);
     }
     $this->nestedChildModelIds[] = $attrValueModel->get_submitted_ids();
     return true;
 }

 /**
  * Overrides the post submit function to add in synonomies
  */
 protected function postSubmit($isInsert)
 {
     $success = true;
     if ($this->submission['fields']['preferred']['value'] == 't') {
         try {
             if (isset($this->submission['metaFields']) && array_key_exists('synonyms', $this->submission['metaFields'])) {
                 $arrSyn = $this->parseRelatedNames($this->submission['metaFields']['synonyms']['value'], 'set_synonym_sub_array');
             } else {
                 $arrSyn = array();
             }
             $meaning_id = $this->submission['fields']['meaning_id']['value'];
             $existingSyn = $this->getSynonomy('meaning_id', $meaning_id);
             // Iterate through existing synonomies, discarding those that have
             // been deleted and removing existing ones from the list to add
             // Not sure this is correct way of doing it as it would appear that you can only have one synonym per language....
             foreach ($existingSyn as $syn) {
                 // Is the term from the db in the list of synonyms?
                 if (array_key_exists($syn->term->language->iso, $arrSyn) && $arrSyn[$syn->term->language->iso] == $syn->term->term) {
                     // This one already in db, so can remove from our array
                     $arrSyn = array_diff_key($arrSyn, array($syn->term->language->iso => ''));
                 } else {
                     // Synonym has been deleted - remove it from the db
                     $syn->deleted = 't';
                     $syn->save();
                 }
             }
             // $arraySyn should now be left only with those synonyms
             // we wish to add to the database
             Kohana::log("info", "Synonyms remaining to add: " . count($arrSyn));
             $sm = ORM::factory('termlists_term');
             foreach ($arrSyn as $lang => $term) {
                 $sm->clear();
                 $syn = array();
                 // Wrap a new submission
                 Kohana::log("debug", "Wrapping submission for synonym " . $term);
                 $lang_id = ORM::factory('language')->where(array('iso' => $lang))->find()->id;
                 // If language not found, use english as the default. Future versions may wish this to be
                 // user definable.
                 $lang_id = $lang_id ? $lang_id : ORM::factory('language')->where(array('iso' => 'eng'))->find()->id;
                 // copy the original post array to pick up the common things, first the taxa_taxon_list data
                 foreach (array('parent', 'sort_order', 'termlist_id') as $field) {
                     if (isset($this->submission['fields'][$field])) {
                         $syn["termlists_term:{$field}"] = is_array($this->submission['fields'][$field]) ? $this->submission['fields'][$field]['value'] : $this->submission['fields'][$field];
                     }
                 }
                 // unlike the taxa there are no term based shared data.
                 // Now update the record with specifics for this synonym
                 $syn['term:id'] = null;
                 $syn['term:term'] = $term;
                 $syn['term:language_id'] = $lang_id;
                 $syn['termlists_term:id'] = '';
                 $syn['termlists_term:preferred'] = 'f';
                 // meaning Id cannot be copied from the submission, since for new data it is generated when saved
                 $syn['termlists_term:meaning_id'] = $meaning_id;
                 // Prevent a recursion by not posting synonyms with a synonym
                 $syn['metaFields:synonyms'] = '';
                 $sub = $this->wrap($syn);
                 // Don't resubmit the meaning record, again we can't rely on the order of the supermodels in the list
                 foreach ($sub['superModels'] as $idx => $supermodel) {
                     if ($supermodel['model']['id'] == 'meaning') {
                         unset($sub['superModels'][$idx]);
                         break;
                     }
                 }
                 $sm->submission = $sub;
                 if (!$sm->submit()) {
                     $success = false;
                     foreach ($sm->errors as $key => $value) {
                         $this->errors[$sm->object_name . ':' . $key] = $value;
                     }
                 }
             }
         } catch (Exception $e) {
             $this->errors['general'] = '<strong>An error occurred</strong><br/>' . $e->getMessage();
             error::log_error('Exception during postSubmit in termlists_term model.', $e);
             $success = false;
         }
     }
     return $success;
 }

    $context["h1"] = "";
		$context["fake_h1"] = _("User") ." ". $a_path[0];

    break;
  case "userprofile-added-quotes":
    echo "lisatud tsitaadid";
    die();
    break;
	default:
		if (!redirect_url($_SERVER["REDIRECT_SCRIPT_URI"]))
		{
			header("HTTP/1.0 404 Not Found"); 
			$context["h1"] = _("");
			$context["fake_h1"] = _("Sorry, but the page was not found!");

			error::log_error($_SERVER["HTTP_HOST"], $_SERVER["SCRIPT_URI"], $_SERVER["HTTP_REFERER"]);
			
			$to = $config_q["admin_email"];
			$subject = "Katkine link " . $_SERVER["HTTP_HOST"] . "'s";
			$body = "Hei, avastasin katkise lingi,\n\n".
			"Täpsemalt:\n".
			"domeen -> " . $_SERVER["HTTP_HOST"] . "\n".
			"katkine link -> " . $_SERVER["SCRIPT_URI"] . "\n".
			"http_referer -> " . $_SERVER["HTTP_REFERER"];
			mail($to, $subject, $body);
		}

/*
		foreach($redirects as $key=>$var)
		{ 
			if ($_SERVER["REDIRECT_SCRIPT_URI"] == $var["from"]) { 

 /**
  * Perform the import
  */
 public function save()
 {
     $surveyId = $_POST['survey_id'];
     try {
         $importData = json_decode($_POST['import_survey_structure'], true);
         $this->doImport($importData, $_POST['survey_id']);
         $this->template->title = 'Import Complete';
         $this->view = new View('survey_structure_export/import_complete');
         $this->view->log = $this->log;
         $this->template->content = $this->view;
     } catch (Exception $e) {
         error::log_error('Exception during survey structure import', $e);
         $this->template->title = 'Error during survey structure import';
         $this->view = new View('templates/error_message');
         $this->view->message = 'An error occurred during the survey structure import. ' . 'Please make sure the import data is valid. More information can be found in the warehouse logs.';
         $this->template->content = $this->view;
     }
     $this->page_breadcrumbs[] = html::anchor('survey', 'Surveys');
     $this->page_breadcrumbs[] = html::anchor('survey/edit/' . $surveyId, $this->surveyTitle);
     $this->page_breadcrumbs[] = $this->template->title;
 }

/**
 * When the scheduled task is run, we need to send a notification to all users who have passed a new milestone
 */
function milestones_scheduled_task($last_run_date, $db)
{
    //Get a list of distinct user/website combinations and  milestones that each combination will need testing for,
    //these are milestones associated with each website the user is associated with, where the milestone has not been
    //awarded yet)
    $occurrenceMilestonesToCheck = get_user_website_combinations_with_unawarded_milestones_for_changed_occurrences($db);
    $mediaMilestonesToCheck = get_user_website_combinations_with_unawarded_milestones_for_changed_occ_media($db);
    //Supply a config of which websites to take into account.
    try {
        $website_ids = kohana::config('milestones.website_ids');
        //Handle config file not present
    } catch (Exception $e) {
        $website_ids = array();
    }
    //handle if config file present but option is not supplied
    if (empty($website_ids)) {
        $website_ids = array();
    }
    //Supply 1 as the user id to give the code maximum privileges
    $reportEngine = new ReportEngine($website_ids, 1);
    $notificationCount = 0;
    //Cycle through all the occurrence media milestones that haven't been awarded yet and could potentially need to be awarded since last run.
    foreach ($mediaMilestonesToCheck as $milestoneToCheck) {
        $report = 'library/occurrences/filterable_occurrence_media_counts_per_user_website';
        $params = json_decode($milestoneToCheck['definition'], true);
        $params['user_id'] = $milestoneToCheck['created_by_id'];
        $params['website_id'] = $milestoneToCheck['website_id'];
        try {
            //Get the report data for all new occurrences that match the filter,user,website.
            $data = $reportEngine->requestReport("{$report}.xml", 'local', 'xml', $params);
        } catch (Exception $e) {
            echo $e->getMessage();
            error::log_error('Error occurred when creating verification notifications based on new occurrences and user\'s filters.', $e);
        }
        foreach ($data['content']['records'] as $milestoneCountData) {
            if ($milestoneCountData['count'] >= $milestoneToCheck['count']) {
                create_milestone_reached_notification($milestoneToCheck);
                $notificationCount++;
            }
        }
    }
    //Cycle through all the occurrence taxa/occurrence milestones that haven't been awarded yet and could potentially need to be awarded since the last run
    foreach ($occurrenceMilestonesToCheck as $milestoneToCheck) {
        if ($milestoneToCheck['milestone_entity'] == 'T') {
            $report = 'library/occurrences/filterable_taxa_counts_per_user_website';
        } else {
            $report = 'library/occurrences/filterable_occurrence_counts_per_user_website';
        }
        $params = json_decode($milestoneToCheck['definition'], true);
        $params['user_id'] = $milestoneToCheck['created_by_id'];
        $params['website_id'] = $milestoneToCheck['website_id'];
        try {
            //Get the report data for all new occurrences that match the filter/user/website
            $data = $reportEngine->requestReport("{$report}.xml", 'local', 'xml', $params);
        } catch (Exception $e) {
            echo $e->getMessage();
            error::log_error('Error occurred when creating verification notifications based on new occurrences and user\'s filters.', $e);
        }
        foreach ($data['content']['records'] as $milestoneCountData) {
            if ($milestoneCountData['count'] >= $milestoneToCheck['count']) {
                create_milestone_reached_notification($milestoneToCheck);
                $notificationCount++;
            }
        }
    }
    if ($notificationCount == 0) {
        echo 'No new milestone notifications have been created.</br>';
    } elseif ($notificationCount == 1) {
        echo '1 new milestone notification has been created.</br>';
    } else {
        echo $notificationCount . ' new milestone notifications have been created.</br>';
    }
}

 /**
  * AJAX callback to handle upload of a single chunk of designations spreadsheet.
  */
 public function csv_upload()
 {
     try {
         $this->auto_render = false;
         $csvTempFile = DOCROOT . "upload/" . $_GET['uploaded_csv'];
         $cache = Cache::instance();
         if (file_exists($csvTempFile)) {
             // Following helps for files from Macs
             ini_set('auto_detect_line_endings', 1);
             // create the file pointer, plus one for errors
             $handle = fopen($csvTempFile, "r");
             $count = 0;
             $limit = isset($_GET['limit']) ? $_GET['limit'] : false;
             $filepos = isset($_GET['filepos']) ? $_GET['filepos'] : 0;
             $offset = isset($_GET['offset']) ? $_GET['offset'] : 0;
             // skip rows to allow for the last file position
             fseek($handle, $filepos);
             if ($filepos == 0) {
                 // skip the headers
                 fgetcsv($handle, 1000, ",");
             }
             $obj = $cache->get(basename($_GET['uploaded_csv']) . 'metadata');
             $errors = array();
             while (($data = fgetcsv($handle, 1000, ",")) !== FALSE && ($limit === false || $count < $limit)) {
                 $line = implode('', $data);
                 // skip blank lines
                 if (empty($line)) {
                     continue;
                 }
                 $count++;
                 $filepos = ftell($handle);
                 $ruleSettings = $this->parse_csv_row($obj['headings'], $data);
                 $uniqueId = $data[$obj['ruleIdColIdx']];
                 if (!empty($uniqueId)) {
                     try {
                         $this->read_rule_content($ruleSettings, $uniqueId, 'csv');
                     } catch (Exception $e) {
                         $errors[] = $e->getMessage();
                         error::log_error('Error during Data Cleaner module CSV upload.', $e);
                     }
                 }
             }
         }
         $progress = $filepos * 100 / filesize($csvTempFile);
         $r = array('uploaded' => $count, 'progress' => $progress, 'filepos' => $filepos, 'errors' => $errors);
         if (count($errors)) {
             kohana::log('debug', 'Upload CSV rule errors: ' . print_r($errors, true));
         } else {
             kohana::log('debug', 'no errors');
         }
         ob_clean();
         echo json_encode($r);
         fclose($handle);
     } catch (Exception $e) {
         error::log_error('Error during Data Cleaner module CSV upload.', $e);
         throw $e;
     }
 }