Search:

CWIS Developers Documentation

  • Main Page
  • Classes
  • Files
  • File List
  • File Members

SavedSearch.php

Go to the documentation of this file.
00001 <?PHP
00002 #
00003 #   FILE:  SavedSearch.php
00004 #
00005 #   NOTES:
00006 #       - the "$SearchGroups" values used herein contain a multi-dimentional
00007 #           array in the form of:
00008 #               $Criteria["MAIN"]["SearchStrings"][<field names>] = <value>
00009 #           for fields with a single value, and:
00010 #               $Criteria[<field ID>]["SearchStrings"][<field name>][] = <value>
00011 #           for fields with multiple values
00012 #
00013 #   Part of the Collection Workflow Integration System (CWIS)
00014 #   Copyright 2011 Edward Almasy and Internet Scout Project
00015 #   http://scout.wisc.edu/
00016 #
00017 
00018 class SavedSearch {
00019 
00020     # ---- PUBLIC INTERFACE --------------------------------------------------
00021 
00022     # search frequency mnemonics
00023     const SEARCHFREQ_NEVER =      0;
00024     const SEARCHFREQ_HOURLY =     1;
00025     const SEARCHFREQ_DAILY =      2;
00026     const SEARCHFREQ_WEEKLY =     3;
00027     const SEARCHFREQ_BIWEEKLY =   4;
00028     const SEARCHFREQ_MONTHLY =    5;
00029     const SEARCHFREQ_QUARTERLY =  6;
00030     const SEARCHFREQ_YEARLY =     7;
00031 
00032     # object constructor
00033     function SavedSearch($SearchId, $SearchName = NULL, $UserId = NULL,
00034             $Frequency = NULL, $SearchGroups = NULL)
00035     {
00036         # get our own database handle
00037         $this->DB = new Database();
00038 
00039         # if search ID was provided
00040         if ($SearchId !== NULL)
00041         {
00042             # save search ID
00043             $this->SearchId = intval($SearchId);
00044 
00045             # initialize our local copies of data
00046             $this->DB->Query("SELECT * FROM SavedSearches"
00047                     ." WHERE SearchId = '".$this->SearchId."'");
00048             $this->Record = $this->DB->FetchRow();
00049 
00050             # update search details where provided
00051             if ($SearchName) {  $this->SearchName($SearchName);  }
00052             if ($UserId)     {  $this->UserId($UserId);  }
00053             if ($Frequency)  {  $this->Frequency($Frequency);  }
00054         }
00055         else
00056         {
00057             # add new saved search to database
00058             $this->DB->Query("INSERT INTO SavedSearches"
00059                     ." (SearchName, UserId, Frequency) VALUES ("
00060                     ."'".addslashes($SearchName)."', "
00061                     .intval($UserId).", "
00062                     .intval($Frequency).")");
00063 
00064             # retrieve and save ID of new search locally
00065             $this->SearchId = $this->DB->LastInsertId("SavedSearches");
00066 
00067             # save frequency and user ID locally
00068             $this->Record["SearchName"] = $SearchName;
00069             $this->Record["UserId"] = $UserId;
00070             $this->Record["Frequency"] = $Frequency;
00071         }
00072 
00073         # save search parameters if provided
00074         if ($SearchGroups) {  $this->SearchGroups($SearchGroups);  }
00075     }
00076 
00077     # get/set search parameters
00078     function SearchGroups($NewSearchGroups = NULL)
00079     {
00080         $Schema = new MetadataSchema();
00081 
00082         # if new search parameters were supplied
00083         if ($NewSearchGroups)
00084         {
00085             # remove existing entries for this search from the database
00086             $this->DB->Query("DELETE FROM SavedSearchTextParameters WHERE SearchId = ".$this->SearchId);
00087             $this->DB->Query("DELETE FROM SavedSearchIdParameters WHERE SearchId = ".$this->SearchId);
00088 
00089             # for each search group
00090             foreach ($NewSearchGroups as $GroupIndex => $Group)
00091             {
00092                 # if group holds single parameters
00093                 if ($GroupIndex == "MAIN")
00094                 {
00095                     # for each field within group
00096                     foreach ($Group["SearchStrings"] as $FieldName => $Value)
00097                     {
00098                         # convert value array to single value (if necessary)
00099                         if (is_array($Value))
00100                         {
00101                             $ConvertedValue = "";
00102                             foreach ($Value as $SingleValue)
00103                             {
00104                                 $ConvertedValue .= $SingleValue." ";
00105                             }
00106                             $Value = trim($ConvertedValue);
00107                         }
00108 
00109                         # add new text search parameter entry to database
00110                         if ($FieldName == "XXXKeywordXXX")
00111                         {
00112                             $FieldId = -101;
00113                         }
00114                         else
00115                         {
00116                             $Field = $Schema->GetFieldByName($FieldName);
00117                             $FieldId = $Field->Id();
00118                         }
00119                         $this->DB->Query("INSERT INTO SavedSearchTextParameters"
00120                                 ." (SearchId, FieldId, SearchText) VALUES"
00121                                 ." (".$this->SearchId.", ".$FieldId.", '".addslashes($Value)."')");
00122                     }
00123                 }
00124                 else
00125                 {
00126                     # convert value(s) as appropriate for field type
00127                     $FieldId = $GroupIndex;
00128                     $Field = $Schema->GetField($FieldId);
00129                     $FieldName = $Field->Name();
00130                     $Values = SavedSearch::TranslateValues($Field, $Group["SearchStrings"][$FieldName], "SearchGroup to Database");
00131 
00132                     # for each converted value
00133                     foreach ($Values as $Value)
00134                     {
00135                         # add new ID search parameter entry to database
00136                         $this->DB->Query("INSERT INTO SavedSearchIdParameters"
00137                                 ." (SearchId, FieldId, SearchValueId) VALUES"
00138                                 ." (".$this->SearchId.", ".$FieldId.", ".$Value.")");
00139                     }
00140                 }
00141             }
00142 
00143             # save search parameters locally
00144             $this->SearchGroups = $NewSearchGroups;
00145         }
00146         else
00147         {
00148             # if search groups not already read in
00149             if (!isset($this->SearchGroups))
00150             {
00151                 # for each text search parameter
00152                 $SearchGroups = array();
00153                 $this->DB->Query("SELECT * FROM SavedSearchTextParameters WHERE SearchId = ".$this->SearchId);
00154                 while ($Record = $this->DB->FetchRow())
00155                 {
00156                     # add parameter to search criteria
00157                     if ($Record["FieldId"] == -101)
00158                     {
00159                         $SearchGroups["MAIN"]["SearchStrings"]["XXXKeywordXXX"] =
00160                                 $Record["SearchText"];
00161                     }
00162                     else
00163                     {
00164                         $Field = $Schema->GetField($Record["FieldId"]);
00165                         $SearchGroups["MAIN"]["SearchStrings"][$Field->Name()] =
00166                                 $Record["SearchText"];
00167                     }
00168                 }
00169 
00170                 # for each value ID search parameter
00171                 $this->DB->Query("SELECT * FROM SavedSearchIdParameters WHERE SearchId = ".$this->SearchId);
00172                 while ($Record = $this->DB->FetchRow())
00173                 {
00174                     # translate value based on field type
00175                     $FieldId = $Record["FieldId"];
00176                     if (!isset($Fields[$FieldId])) {  $Fields[$FieldId] = new MetadataField($FieldId);  }
00177                     $Values = SavedSearch::TranslateValues($Fields[$FieldId],
00178                             $Record["SearchValueId"], "Database to SearchGroup");
00179 
00180                     # add parameter to search criteria
00181                     foreach ($Values as $Value)
00182                     {
00183                         $SearchGroups[$FieldId]["SearchStrings"][$Fields[$FieldId]->Name()][] = $Value;
00184                     }
00185                 }
00186 
00187                 # set appropriate logic in search parameters
00188                 foreach ($SearchGroups as $GroupIndex => $Group)
00189                 {
00190                     $SearchGroups[$GroupIndex]["Logic"] =
00191                             ($GroupIndex == "MAIN") ? SearchEngine::LOGIC_AND
00192                             : SearchEngine::LOGIC_OR;
00193                 }
00194 
00195                 # save search parameters locally
00196                 $this->SearchGroups = $SearchGroups;
00197             }
00198         }
00199 
00200         # return search parameters to caller
00201         return $this->SearchGroups;
00202     }
00203 
00209     function SearchName($NewValue = DB_NOVALUE)
00210             {  return $this->UpdateValue("SearchName", $NewValue);  }
00211 
00216     function Id() {  return $this->SearchId;  }
00217 
00223     function UserId($NewValue = DB_NOVALUE)
00224             {  return $this->UpdateValue("UserId", $NewValue);  }
00225 
00231     function Frequency($NewValue = DB_NOVALUE)
00232             {  return $this->UpdateValue("Frequency", $NewValue);  }
00233 
00234     # set date search was last run to current date/time
00235     function UpdateDateLastRun()
00236     {
00237         $this->DB->Query("UPDATE SavedSearches SET DateLastRun = NOW() WHERE SearchId = ".$this->SearchId);
00238     }
00239 
00240     # get/set date search was last run
00241     function DateLastRun($NewValue = DB_NOVALUE)
00242             {  return $this->UpdateValue("DateLastRun", $NewValue);  }
00243 
00249     function GetSearchGroupsAsUrlParameters()
00250     {
00251         return self::TranslateSearchGroupsToUrlParameters($this->SearchGroups());
00252     }
00253 
00260     static function TranslateSearchGroupsToUrlParameters($SearchGroups)
00261     {
00262         # assume that no parameters will be found
00263         $UrlPortion = "";
00264 
00265         # for each group in parameters
00266         $Schema = new MetadataSchema();
00267         foreach ($SearchGroups as $GroupIndex => $Group)
00268         {
00269             # if group holds single parameters
00270             if ($GroupIndex == "MAIN")
00271             {
00272                 # for each field within group
00273                 foreach ($Group["SearchStrings"] as $FieldName => $Value)
00274                 {
00275                     # add segment to URL for this field
00276                     if ($FieldName == "XXXKeywordXXX")
00277                     {
00278                         $FieldId = "K";
00279                     }
00280                     else
00281                     {
00282                         $Field = $Schema->GetFieldByName($FieldName);
00283                         $FieldId = $Field->Id();
00284                     }
00285                     if (is_array($Value))
00286                     {
00287                         $UrlPortion .= "&F".$FieldId."=";
00288                         $ValueString = "";
00289                         foreach ($Value as $SingleValue)
00290                         {
00291                             $ValueString .= $SingleValue." ";
00292                         }
00293                         $UrlPortion .= urlencode(trim($ValueString));
00294                     }
00295                     else
00296                     {
00297                         $UrlPortion .= "&F".$FieldId."=".urlencode($Value);
00298                     }
00299                 }
00300             }
00301             else
00302             {
00303                 # convert value based on field type
00304                 $FieldId = $GroupIndex;
00305                 $Field = $Schema->GetField($FieldId);
00306                 $FieldName = $Field->Name();
00307                 $Values = SavedSearch::TranslateValues($Field, $Group["SearchStrings"][$FieldName], "SearchGroup to Database");
00308 
00309                 # add values to URL
00310                 $FirstValue = TRUE;
00311                 foreach ($Values as $Value)
00312                 {
00313                     if ($FirstValue)
00314                     {
00315                         $FirstValue = FALSE;
00316                         $UrlPortion .= "&G".$FieldId."=".$Value;
00317                     }
00318                     else
00319                     {
00320                         $UrlPortion .= "-".$Value;
00321                     }
00322                 }
00323             }
00324         }
00325 
00326         # trim off any leading "&"
00327         if (strlen($UrlPortion)) {  $UrlPortion = substr($UrlPortion, 1);  }
00328 
00329         # return URL portion to caller
00330         return $UrlPortion;
00331     }
00332 
00338     function GetSearchGroupsAsUrlParameterArray()
00339     {
00340         return self::TranslateSearchGroupsToUrlParameters($this->SearchGroups());
00341     }
00342 
00349     static function TranslateSearchGroupsToUrlParameterArray($SearchGroups)
00350     {
00351         # assume that no parameters will be found
00352         $UrlPortion = array();
00353 
00354         # for each group in parameters
00355         $Schema = new MetadataSchema();
00356         foreach ($SearchGroups as $GroupIndex => $Group)
00357         {
00358             # if group holds single parameters
00359             if ($GroupIndex == "MAIN")
00360             {
00361                 # for each field within group
00362                 foreach ($Group["SearchStrings"] as $FieldName => $Value)
00363                 {
00364                     # add segment to URL for this field
00365                     if ($FieldName == "XXXKeywordXXX")
00366                     {
00367                         $FieldId = "K";
00368                     }
00369                     else
00370                     {
00371                         $Field = $Schema->GetFieldByName($FieldName);
00372                         $FieldId = $Field->Id();
00373                     }
00374                     if (is_array($Value))
00375                     {
00376                         $ValueString = "";
00377                         foreach ($Value as $SingleValue)
00378                         {
00379                             $ValueString .= $SingleValue." ";
00380                         }
00381 
00382                         $UrlPortion["F".$FieldId] = urlencode(trim($ValueString));
00383                     }
00384                     else
00385                     {
00386                         $UrlPortion["F".$FieldId] = urlencode($Value);
00387                     }
00388                 }
00389             }
00390             else
00391             {
00392                 # convert value based on field type
00393                 $FieldId = $GroupIndex;
00394                 $Field = $Schema->GetField($FieldId);
00395                 $FieldName = $Field->Name();
00396                 $Values = SavedSearch::TranslateValues($Field, $Group["SearchStrings"][$FieldName], "SearchGroup to Database");
00397 
00398                 # add values to URL
00399                 $FirstValue = TRUE;
00400                 foreach ($Values as $Value)
00401                 {
00402                     if ($FirstValue)
00403                     {
00404                         $FirstValue = FALSE;
00405                         $UrlPortion["G".$FieldId] = $Value;
00406                     }
00407                     else
00408                     {
00409                         $UrlPortion["G".$FieldId] .= "-".$Value;
00410                     }
00411                 }
00412             }
00413         }
00414 
00415         # return URL portion to caller
00416         return $UrlPortion;
00417     }
00418 
00419     # set search groups from URL (GET method) parameters
00420     # (returns search group array)
00421     static function TranslateUrlParametersToSearchGroups($GetVars)
00422     {
00423         # if URL segment was passed in instead of GET var array
00424         if (is_string($GetVars))
00425         {
00426             parse_str($GetVars, $GetVars);
00427         }
00428 
00429         # start with empty list of parameters
00430         $SearchGroups = array();
00431 
00432         $Schema = new MetadataSchema();
00433         $AllFields = $Schema->GetFields(NULL, NULL, TRUE);
00434 
00435         foreach ($AllFields as $Field)
00436         {
00437             $FieldId = $Field->Id();
00438             $FieldName = $Field->Name();
00439 
00440             # if URL included literal value for this field
00441             if (isset($GetVars["F".$FieldId]))
00442             {
00443                 # retrieve value and add to search parameters
00444                 $SearchGroups["MAIN"]["SearchStrings"][$FieldName] = $GetVars["F".$FieldId];
00445             }
00446 
00447             # if URL included group value for this field
00448             if (isset($GetVars["G".$FieldId]))
00449             {
00450                 # retrieve and parse out values
00451                 $Values = explode("-", $GetVars["G".$FieldId]);
00452 
00453                 # translate values
00454                 $Values = SavedSearch::TranslateValues($Field, $Values, "Database to SearchGroup");
00455 
00456                 # add values to searchgroups
00457                 $SearchGroups[$FieldId]["SearchStrings"][$FieldName] = $Values;
00458             }
00459         }
00460 
00461         # if keyword pseudo-field was included in URL
00462         if (isset($GetVars["FK"]))
00463         {
00464             # retrieve value and add to search parameters
00465             $SearchGroups["MAIN"]["SearchStrings"]["XXXKeywordXXX"] = $GetVars["FK"];
00466         }
00467 
00468         # set search logic
00469         foreach ($SearchGroups as $GroupIndex => $Group)
00470         {
00471             $SearchGroups[$GroupIndex]["Logic"] = ($GroupIndex == "MAIN")
00472                     ? SearchEngine::LOGIC_AND : SearchEngine::LOGIC_OR;
00473         }
00474 
00475         # return parameters to caller
00476         return $SearchGroups;
00477     }
00478 
00489     function GetSearchGroupsAsTextDescription(
00490             $IncludeHtml = TRUE, $StartWithBreak = TRUE, $TruncateLongWordsTo = 0)
00491     {
00492         return self::TranslateSearchGroupsToTextDescription($this->SearchGroups(),
00493             $IncludeHtml, $StartWithBreak, $TruncateLongWordsTo);
00494     }
00495 
00507     static function TranslateSearchGroupsToTextDescription($SearchGroups,
00508             $IncludeHtml = TRUE, $StartWithBreak = TRUE, $TruncateLongWordsTo = 0)
00509     {
00510         $Schema = new MetadataSchema();
00511 
00512         # start with empty description
00513         $Descrip = "";
00514 
00515         # set characters used to indicate literal strings
00516         $LiteralStart = $IncludeHtml ? "<i>" : "\"";
00517         $LiteralEnd = $IncludeHtml ? "</i>" : "\"";
00518         $LiteralBreak = $IncludeHtml ? "<br>\n" : "\n";
00519 
00520         # if this is a simple keyword search
00521         if (isset($SearchGroups["MAIN"]["SearchStrings"]["XXXKeywordXXX"])
00522             && (count($SearchGroups) == 1)
00523             && (count($SearchGroups["MAIN"]["SearchStrings"]) == 1))
00524         {
00525             # just use the search string
00526             $Descrip .= $LiteralStart;
00527             $Descrip .= defaulthtmlentities($SearchGroups["MAIN"]["SearchStrings"]["XXXKeywordXXX"]);
00528             $Descrip .= $LiteralEnd . $LiteralBreak;
00529         }
00530         else
00531         {
00532             # start description on a new line (if requested)
00533             if ($StartWithBreak)
00534             {
00535                 $Descrip .= $LiteralBreak;
00536             }
00537 
00538             # define list of phrases used to represent logical operators
00539             $WordsForOperators = array(
00540                     "=" => "is",
00541                     ">" => "is greater than",
00542                     "<" => "is less than",
00543                     ">=" => "is at least",
00544                     "<=" => "is no more than",
00545                     "!" => "is not",
00546                     );
00547 
00548             # for each search group
00549             foreach ($SearchGroups as $GroupIndex => $Group)
00550             {
00551                 # if group is main
00552                 if ($GroupIndex == "MAIN")
00553                 {
00554                     # for each field in group
00555                     foreach ($Group["SearchStrings"] as $FieldName => $Value)
00556                     {
00557                         # convert keyword pseudo-field name if necessary
00558                         if ($FieldName == "XXXKeywordXXX") {  $FieldName = "Keyword";  }
00559 
00560                         # determine wording based on operator
00561                         preg_match("/^[=><!]+/", $Value, $Matches);
00562                         if (count($Matches) && isset($WordsForOperators[$Matches[0]]))
00563                         {
00564                             $Value = preg_replace("/^[=><!]+/", "", $Value);
00565                             $Wording = $WordsForOperators[$Matches[0]];
00566                         }
00567                         else
00568                         {
00569                             $Wording = "contains";
00570                         }
00571 
00572                         $Field = $Schema->GetFieldByName($FieldName);
00573 
00574                         # get display name for field
00575                         if ($Field && $Field->Status() == MetadataSchema::MDFSTAT_OK)
00576                         {
00577                             $FieldName = $Field->GetDisplayName();
00578                         }
00579 
00580                         # add criteria for field
00581                         $Descrip .= $FieldName." ".$Wording." "
00582                                 .$LiteralStart.htmlspecialchars($Value)
00583                                         .$LiteralEnd.$LiteralBreak;
00584                     }
00585                 }
00586                 else
00587                 {
00588                     # for each field in group
00589                     foreach ($Group["SearchStrings"] as $FieldName => $Values)
00590                     {
00591                         # translate values
00592                         $Values = SavedSearch::TranslateValues($FieldName, $Values, "SearchGroup to Display");
00593 
00594                         # for each value
00595                         $FirstValue = TRUE;
00596                         foreach ($Values as $Value)
00597                         {
00598                             # determine wording based on operator
00599                             preg_match("/^[=><!]+/", $Value, $Matches);
00600                             $Operator = $Matches[0];
00601                             $Wording = $WordsForOperators[$Operator];
00602 
00603                             # strip off operator
00604                             $Value = preg_replace("/^[=><!]+/", "", $Value);
00605 
00606                             # add text to description
00607                             if ($FirstValue)
00608                             {
00609                                 $Descrip .= $FieldName." ".$Wording." ".$LiteralStart.htmlspecialchars($Value).$LiteralEnd.$LiteralBreak;
00610                                 $FirstValue = FALSE;
00611                             }
00612                             else
00613                             {
00614                                 $Descrip .= ($IncludeHtml ? "&nbsp;&nbsp;&nbsp;&nbsp;" : "    ")
00615                                         ."or ".$Wording." ".$LiteralStart
00616                                         .htmlspecialchars($Value).$LiteralEnd
00617                                         .$LiteralBreak;
00618                             }
00619                         }
00620                     }
00621                 }
00622             }
00623         }
00624 
00625         # if caller requested that long words be truncated
00626         if ($TruncateLongWordsTo > 4)
00627         {
00628             # break description into words
00629             $Words = explode(" ", $Descrip);
00630 
00631             # for each word
00632             $NewDescrip = "";
00633             foreach ($Words as $Word)
00634             {
00635                 # if word is longer than specified length
00636                 if (strlen(strip_tags($Word)) > $TruncateLongWordsTo)
00637                 {
00638                     # truncate word and add ellipsis
00639                     $Word = NeatlyTruncateString($Word, $TruncateLongWordsTo - 3);
00640                 }
00641 
00642                 # add word to new description
00643                 $NewDescrip .= " ".$Word;
00644             }
00645 
00646             # set description to new description
00647             $Descrip = $NewDescrip;
00648         }
00649 
00650         # return description to caller
00651         return $Descrip;
00652     }
00653 
00658     function GetSearchFieldNames()
00659     {
00660         return self::TranslateSearchGroupsToSearchFieldNames($this->SearchGroups());
00661     }
00662 
00668     static function TranslateSearchGroupsToSearchFieldNames($SearchGroups)
00669     {
00670         # start out assuming no fields are being searched
00671         $FieldNames = array();
00672 
00673         # for each search group defined
00674         foreach ($SearchGroups as $GroupIndex => $Group)
00675         {
00676             # for each field in group
00677             foreach ($Group["SearchStrings"] as $FieldName => $Values)
00678             {
00679                 # add field name to list of fields being searched
00680                 $FieldNames[] = $FieldName;
00681             }
00682         }
00683 
00684         # return list of fields being searched to caller
00685         return $FieldNames;
00686     }
00687 
00693     static function GetSearchFrequencyList()
00694     {
00695         # define list with descriptions
00696         $FreqDescr = array(
00697                 self::SEARCHFREQ_NEVER     => "Never",
00698                 self::SEARCHFREQ_HOURLY    => "Hourly",
00699                 self::SEARCHFREQ_DAILY     => "Daily",
00700                 self::SEARCHFREQ_WEEKLY    => "Weekly",
00701                 self::SEARCHFREQ_BIWEEKLY  => "Bi-Weekly",
00702                 self::SEARCHFREQ_MONTHLY   => "Monthly",
00703                 self::SEARCHFREQ_QUARTERLY => "Quarterly",
00704                 self::SEARCHFREQ_YEARLY    => "Yearly",
00705                 );
00706 
00707         # for each argument passed in
00708         $Args = func_get_args();
00709         foreach ($Args as $Arg)
00710         {
00711             # remove value from list
00712             $FreqDescr = array_diff_key($FreqDescr, array($Arg => ""));
00713         }
00714 
00715         # return list to caller
00716         return $FreqDescr;
00717     }
00718 
00722     function Delete()
00723     {
00724         $this->DB->Query("DELETE FROM SavedSearches"
00725                 ." WHERE SearchId = ".intval($this->SearchId));
00726         $this->DB->Query("DELETE FROM SavedSearchTextParameters"
00727                 ." WHERE SearchId = ".intval($this->SearchId));
00728         $this->DB->Query("DELETE FROM SavedSearchIdParameters"
00729                 ." WHERE SearchId = ".intval($this->SearchId));
00730     }
00731 
00732 
00733     # ---- PRIVATE INTERFACE -------------------------------------------------
00734 
00735     private $SearchId;
00736     private $Record;
00737     private $SearchGroups;
00738 
00739     # utility function to convert between value representations
00740     # (method accepts a value or array and always return an array)
00741     # (this is needed because values are represented differently:
00742     #                                 FLAG    USER    OPTION
00743     #     in DB / in URL / in forms   0/1     123     456
00744     #     used in SearchGroups        0/1     jdoe    cname
00745     #     displayed to user           On/Off  jdoe    cname
00746     # where "123" and "456" are option or controlled name IDs)
00747     private static function TranslateValues($FieldOrFieldName, $Values, $TranslationType)
00748     {
00749         # start out assuming we won't find any values to translate
00750         $ReturnValues = array();
00751 
00752         # convert field name to field object if necessary
00753         if (is_object($FieldOrFieldName))
00754         {
00755             $Field = $FieldOrFieldName;
00756         }
00757         else
00758         {
00759             static $Schema;
00760             if (!isset($Schema)) {  $Schema = new MetadataSchema();  }
00761             $Field = $Schema->GetFieldByName($FieldOrFieldName);
00762         }
00763 
00764         # if incoming value is not an array
00765         if (!is_array($Values))
00766         {
00767             # convert incoming value to an array
00768             $Values = array($Values);
00769         }
00770 
00771         # for each incoming value
00772         foreach ($Values as $Value)
00773         {
00774             switch ($TranslationType)
00775             {
00776                 case "SearchGroup to Display":
00777                     # if field is Flag field
00778                     if ($Field->Type() == MetadataSchema::MDFTYPE_FLAG)
00779                     {
00780                         # translate value to true/false label and add leading operator
00781                         $ReturnValues[] = ($Value == "=1") ? "=".$Field->FlagOnLabel() : "=".$Field->FlagOffLabel();
00782                     }
00783                     elseif ($Field->Name() == "Cumulative Rating")
00784                     {
00785                         # translate numeric value to stars
00786                         $StarStrings = array(
00787                                 "20" => "*",
00788                                 "40" => "**",
00789                                 "60" => "***",
00790                                 "80" => "****",
00791                                 "100" => "*****",
00792                                 );
00793                         preg_match("/[0-9]+$/", $Value, $Matches);
00794                         $Number = $Matches[0];
00795                         preg_match("/^[=><!]+/", $Value, $Matches);
00796                         $Operator = $Matches[0];
00797                         $ReturnValues[] = $Operator.$StarStrings[$Number];
00798                     }
00799                     else
00800                     {
00801                         # use value as is
00802                         $ReturnValues[] = $Value;
00803                     }
00804                     break;
00805 
00806                 case "SearchGroup to Database":
00807                     # strip off leading operator on value
00808                     $Value = preg_replace("/^[=><!]+/", "", $Value);
00809 
00810                     # look up index for value
00811                     if ($Field->Type() & (MetadataSchema::MDFTYPE_FLAG|MetadataSchema::MDFTYPE_NUMBER))
00812                     {
00813                         # (for flag or number fields the value index is already what is used in SearchGroups)
00814                         if ($Value >= 0)
00815                         {
00816                             $ReturnValues[] = $Value;
00817                         }
00818                     }
00819                     elseif ($Field->Type() == MetadataSchema::MDFTYPE_USER)
00820                     {
00821                         # (for user fields the value index is the user ID)
00822                         $User = new SPTUser(strval($Value));
00823                         if ($User)
00824                         {
00825                             $ReturnValues[] = $User->Id();
00826                         }
00827                     }
00828                     elseif ($Field->Type() == MetadataSchema::MDFTYPE_OPTION)
00829                     {
00830                         if (!isset($PossibleFieldValues))
00831                         {
00832                             $PossibleFieldValues = $Field->GetPossibleValues();
00833                         }
00834                         $NewValue = array_search($Value, $PossibleFieldValues);
00835                         if ($NewValue !== FALSE)
00836                         {
00837                             $ReturnValues[] = $NewValue;
00838                         }
00839                     }
00840                     else
00841                     {
00842                         $NewValue = $Field->GetIdForValue($Value);
00843                         if ($NewValue !== NULL)
00844                         {
00845                             $ReturnValues[] = $NewValue;
00846                         }
00847                     }
00848                     break;
00849 
00850                 case "Database to SearchGroup":
00851                     # look up value for index
00852                     if ($Field->Type() == MetadataSchema::MDFTYPE_FLAG)
00853                     {
00854                         # (for flag fields the value index (0 or 1) is already what is used in Database)
00855                         if ($Value >= 0)
00856                         {
00857                             $ReturnValues[] = "=".$Value;
00858                         }
00859                     }
00860                     elseif ($Field->Type() == MetadataSchema::MDFTYPE_NUMBER)
00861                     {
00862                         # (for flag fields the value index (0 or 1) is already what is used in Database)
00863                         if ($Value >= 0)
00864                         {
00865                             $ReturnValues[] = ">=".$Value;
00866                         }
00867                     }
00868                     elseif ($Field->Type() == MetadataSchema::MDFTYPE_USER)
00869                     {
00870                         $User = new SPTUser(intval($Value));
00871                         if ($User)
00872                         {
00873                             $ReturnValues[] = "=".$User->Get("UserName");
00874                         }
00875                     }
00876                     elseif ($Field->Type() == MetadataSchema::MDFTYPE_OPTION)
00877                     {
00878                         if (!isset($PossibleFieldValues))
00879                         {
00880                             $PossibleFieldValues = $Field->GetPossibleValues();
00881                         }
00882 
00883                         if (isset($PossibleFieldValues[$Value]))
00884                         {
00885                             $ReturnValues[] = "=".$PossibleFieldValues[$Value];
00886                         }
00887                     }
00888                     else
00889                     {
00890                         $NewValue = $Field->GetValueForId($Value);
00891                         if ($NewValue !== NULL)
00892                         {
00893                             $ReturnValues[] = "=".$NewValue;
00894                         }
00895                     }
00896                     break;
00897             }
00898         }
00899 
00900         # return array of translated values to caller
00901         return $ReturnValues;
00902     }
00903 
00906     # utility function for updating values in database
00907     private function UpdateValue($FieldName, $NewValue)
00908     {
00909         return $this->DB->UpdateValue("SavedSearches", $FieldName, $NewValue,
00910                "SearchId = ".$this->SearchId, $this->Record);
00911     }
00912 
00913     # legacy methods for backward compatibility
00914     function GetSearchId() {  return $this->Id();  }
00915 
00917 }

CWIS logo doxygen
Copyright 2010 Internet Scout