Search:

# CWIS Developers Documentation

- Main Page
- Classes
- Files

- Search for |

- File List
- File Members

# SavedSearch.php

Go to the documentation of this file.

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