Search:

CWIS Developers Documentation

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

SPTOAIServer.php

Go to the documentation of this file.
00001 <?PHP
00002 
00003 #
00004 #   FILE:  SPT--SPTOAIServer.php
00005 #
00006 #   METHODS PROVIDED:
00007 #       SPTOAIServer()
00008 #           - constructor
00009 #
00010 #   AUTHOR:  Edward Almasy
00011 #
00012 #   Part of the Scout Portal Toolkit
00013 #   Copyright 2002-2004 Internet Scout Project
00014 #   http://scout.wisc.edu
00015 #
00016 
00017 class SPTOAIServer extends OAIServer {
00018 
00019     # ---- PUBLIC INTERFACE --------------------------------------------------
00020 
00021     function SPTOAIServer($RetrievalSearchParameters = NULL)
00022     {
00023         global $SysConfig;
00024 
00025         # grab our own database handle
00026         $this->DB = new SPTDatabase();
00027         $DB =& $this->DB;
00028 
00029         # set up repository description
00030         $DB->Query("SELECT * FROM SystemConfiguration");
00031         $Record = $DB->FetchRow();
00032         $RepDescr["Name"]            = $SysConfig->PortalName();
00033         $ServerName = ($_SERVER["SERVER_NAME"] != "127.0.0.1")
00034                 ? $_SERVER["SERVER_NAME"]
00035                 : $_SERVER["HTTP_HOST"];
00036         $RepDescr["BaseURL"]         = "http://".$ServerName.$_SERVER["SCRIPT_NAME"];
00037         $RepDescr["DateGranularity"] = "DATE";
00038         $RepDescr["EarliestDate"]    = $Record["OaiEarliestDate"];
00039         $RepDescr["AdminEmail"][]    = $SysConfig->AdminEmail();
00040         $RepDescr["IDDomain"]        = $Record["OaiIdDomain"];
00041         $RepDescr["IDPrefix"]        = $Record["OaiIdPrefix"];
00042 
00043         # create item factory object for retrieving items from DB
00044         $this->SPTItemFactory = new SPTOAIItemFactory($RetrievalSearchParameters);
00045 
00046         # call parent's constructor
00047         $this->OAIServer($DB, $RepDescr, $this->SPTItemFactory, TRUE, $SysConfig->OAISQEnabled());
00048 
00049         # set up description of nsdl_dc format
00050         $NsdldcNamespaceList = array(
00051             "nsdl_dc" => "http://ns.nsdl.org/nsdl_dc_v1.01",
00052             "dc" => "http://purl.org/dc/elements/1.1/",
00053             "dct" => "http://purl.org/dc/terms/",
00054             "ieee" => "http://www.ieee.org/xsd/LOMv1p0",
00055             );
00056         $NsdldcElements = array(
00057             "dc:title",
00058             "dc:creator",
00059             "dc:subject",
00060             "dc:description",
00061             "dc:publisher",
00062             "dc:contributor",
00063             "dc:date",
00064             "dc:type",
00065             "dc:format",
00066             "dc:identifier",
00067             "dc:source",
00068             "dc:language",
00069             "dc:relation",
00070             "dc:coverage",
00071             "dc:rights",
00072             "dct:audience",
00073             "dct:alternative",
00074             "dct:tableOfContents",
00075             "dct:abstract",
00076             "dct:created",
00077             "dct:valid",
00078             "dct:available",
00079             "dct:issued",
00080             "dct:modified",
00081             "dct:extent",
00082             "dct:medium",
00083             "dct:isVersionOf",
00084             "dct:hasVersion",
00085             "dct:isReplacedBy",
00086             "dct:replaces",
00087             "dct:isRequiredBy",
00088             "dct:requires",
00089             "dct:isPartOf",
00090             "dct:hasPart",
00091             "dct:isReferencedBy",
00092             "dct:references",
00093             "dct:isFormatOf",
00094             "dct:hasFormat",
00095             "dct:conformsTo",
00096             "dct:spatial",
00097             "dct:temporal",
00098             "dct:mediator",
00099             "dct:dateAccepted",
00100             "dct:dateCopyrighted",
00101             "dct:dateSubmitted",
00102             "dct:educationLevel",
00103             "dct:accessRights",
00104             "dct:bibliographicCitation",
00105             "ieee:interactivityType",
00106             "ieee:interactivityLevel",
00107             "ieee:typicalLearningTime",
00108             );
00109         $NsdldcQualifiers = array(
00110             "dct:LCSH",
00111             "dct:MESH",
00112             "dct:DDC",
00113             "dct:LCC",
00114             "dct:UDC",
00115             "dct:DCMIType",
00116             "dct:IMT",
00117             "dct:ISO639-2",
00118             "dct:RFC1766",
00119             "dct:URI",
00120             "dct:Point",
00121             "dct:ISO3166",
00122             "dct:Box",
00123             "dct:TGN",
00124             "dct:Period",
00125             "dct:W3CDTF",
00126             "dct:RFC3066",
00127             );
00128         $this->AddFormat("nsdl_dc", "nsdl_dc:nsdl_dc",
00129                          "http://ns.nsdl.org/nsdl_dc_v1.01"
00130                          ." http://ns.nsdl.org/schemas/nsdl_dc/nsdl_dc_v1.01.xsd",
00131                          "1.01.001",
00132                          $NsdldcNamespaceList, $NsdldcElements, $NsdldcQualifiers);
00133 
00134         # load field mappings from database and set in parent
00135         $Schema = new MetadataSchema();
00136         $DB->Query("SELECT * FROM OAIFieldMappings");
00137         while ($Record = $DB->FetchRow())
00138         {
00139             if ($Record["OAIFieldName"] != "Unmapped")
00140             {
00141                 parent::SetFieldMapping($Record["FormatName"],
00142                                         $Record["SPTFieldId"],
00143                                         $Record["OAIFieldName"]);
00144             }
00145         }
00146 
00147         # load qualifier mappings from database and set in parent
00148         $DB->Query("SELECT * FROM OAIQualifierMappings");
00149         while ($Record = $DB->FetchRow())
00150         {
00151             if ($Record["OAIQualifierName"] != "Unmapped")
00152             {
00153                 $LocalQualifier = new Qualifier($Record["SPTQualifierId"]);
00154                 $LocalQualifierName = $LocalQualifier->Name();
00155                 parent::SetQualifierMapping($Record["FormatName"],
00156                                         $LocalQualifierName,
00157                                         $Record["OAIQualifierName"]);
00158             }
00159         }
00160     }
00161 
00162     # add SQL conditional for selecting resources
00163     function AddSQLConditionalForResources($Conditional)
00164     {
00165         # pass conditional on to item factory
00166         $this->SPTItemFactory->AddSQLConditionalForResources($Conditional);
00167     }
00168 
00169     # get/set mapping of local field to OAI field (overloads parent method)
00170     function GetFieldMapping($FormatName, $LocalFieldName)
00171     {
00172         # retrieve ID for local field
00173         $Schema = new MetadataSchema();
00174         $LocalField = $Schema->GetFieldByName($LocalFieldName);
00175         $LocalFieldId = $LocalField->Id();
00176 
00177         # return stored value
00178         return parent::GetFieldMapping($FormatName, $LocalFieldId);
00179     }
00180     function SetFieldMapping($FormatName, $LocalFieldName, $OAIFieldName)
00181     {
00182         # retrieve ID for local field
00183         $Schema = new MetadataSchema();
00184         $LocalField = $Schema->GetFieldByName($LocalFieldName);
00185         $LocalFieldId = $LocalField->Id();
00186 
00187         # check whether mapping is already in database
00188         $DB =& $this->DB;
00189         $MapCount = $DB->Query("SELECT COUNT(*) AS MapCount FROM OAIFieldMappings"
00190                                ." WHERE FormatName = '".$FormatName."'"
00191                                ." AND SPTFieldId = '".$LocalFieldId."'",
00192                                "MapCount");
00193 
00194         # if mapping is already in database
00195         if ($MapCount > 0)
00196         {
00197             # change mapping in database
00198             $DB->Query("UPDATE OAIFieldMappings"
00199                        ." SET OAIFieldName = '".addslashes($OAIFieldName)."'"
00200                        ." WHERE FormatName = '".addslashes($FormatName)."'"
00201                        ." AND SPTFieldId = '".$LocalFieldId."'");
00202         }
00203         else
00204         {
00205             # add new mapping to database
00206             $DB->Query("INSERT INTO OAIFieldMappings"
00207                        ." (FormatName, SPTFieldId, OAIFieldName) VALUES"
00208                        ." ('".addslashes($FormatName)."', '".$LocalFieldId
00209                        ."', '".addslashes($OAIFieldName)."')");
00210         }
00211 
00212         # call parent method
00213         parent::SetFieldMapping($FormatName, $LocalFieldId, $OAIFieldName);
00214     }
00215 
00216     # set mapping of local qualifier to OAI qualifier (overloads parent method)
00217     function SetQualifierMapping($FormatName, $LocalQualifierName, $OAIQualifierName)
00218     {
00219         # retrieve ID for local qualifier
00220         $QFactory = new QualifierFactory();
00221         $LocalQualifier = $QFactory->GetQualifierByName($LocalQualifierName);
00222         $LocalQualifierId = $LocalQualifier->Id();
00223 
00224         # check whether mapping is already in database
00225         $DB =& $this->DB;
00226         $MapCount = $DB->Query("SELECT COUNT(*) AS MapCount FROM OAIQualifierMappings"
00227                                ." WHERE FormatName = '".addslashes($FormatName)."'"
00228                                ." AND SPTQualifierId = '".$LocalQualifierId."'",
00229                                "MapCount");
00230 
00231         # if mapping is already in database
00232         if ($MapCount > 0)
00233         {
00234             # change mapping in database
00235             $DB->Query("UPDATE OAIQualifierMappings"
00236                        ." SET OAIQualifierName = '".addslashes($OAIQualifierName)."'"
00237                        ." WHERE FormatName = '".addslashes($FormatName)."'"
00238                        ." AND SPTQualifierId = '".$LocalQualifierId."'");
00239         }
00240         else
00241         {
00242             # add new mapping to database
00243             $DB->Query("INSERT INTO OAIQualifierMappings"
00244                        ." (FormatName, SPTQualifierId, OAIQualifierName) VALUES"
00245                        ." ('".addslashes($FormatName)."', '".$LocalQualifierId
00246                        ."', '".addslashes($OAIQualifierName)."')");
00247         }
00248 
00249         # call parent method
00250         parent::SetQualifierMapping($FormatName, $LocalQualifierName, $OAIQualifierName);
00251     }
00252 
00253 
00254     # ---- PRIVATE INTERFACE -------------------------------------------------
00255 
00256     var $DB;
00257     var $SPTItemFactory;
00258 
00259 }
00260 
00261 class SPTOAIItemFactory extends OAIItemFactory {
00262 
00263     # ---- PUBLIC INTERFACE --------------------------------------------------
00264 
00265     # object constructor
00266     function SPTOAIItemFactory($RetrievalSearchParameters = NULL)
00267     {
00268         # save any supplied retrieval parameters
00269         $this->RetrievalSearchParameters = $RetrievalSearchParameters;
00270     }
00271 
00272     function GetItem($ItemId)
00273     {
00274         # add link to full record page for item
00275         $ServerName = ($_SERVER["SERVER_NAME"] != "127.0.0.1")
00276                 ? $_SERVER["SERVER_NAME"]
00277                 : $_SERVER["HTTP_HOST"];
00278         $SearchInfo["fullRecordLink"] = "http://".$ServerName.dirname($_SERVER["SCRIPT_NAME"])."/SPT--FullRecord.php?ResourceId=".$ItemId;
00279 
00280         # if a search score is available for the item
00281         if (isset($this->SearchScores) && isset($this->SearchScores[$ItemId]))
00282         {
00283             # add search info for item
00284             $SearchInfo["searchScore"] = $this->SearchScores[$ItemId];
00285             $SearchInfo["searchScoreScale"] = $this->SearchScoreScale;
00286         }
00287 
00288         # attempt to create item
00289         $Item = new SPTOAIItem($ItemId, $SearchInfo);
00290 
00291         # if item creation failed
00292         if ($Item->Status() == -1)
00293         {
00294             # return NULL to indicate that no item was found with that ID
00295             return NULL;
00296         }
00297         else
00298         {
00299             # return item to caller
00300             return $Item;
00301         }
00302     }
00303 
00304     function GetItems($StartingDate = NULL, $EndingDate = NULL)
00305     {
00306         return $this->GetItemsInSet(NULL, $StartingDate, $EndingDate);
00307     }
00308 
00309     function GetItemsInSet($Set, $StartingDate = NULL, $EndingDate = NULL)
00310     {
00311         # initialize search parameters with release flag requirement
00312         $SearchStrings["Release Flag"] = "=1";
00313 
00314         # if both begin and end date supplied
00315         if (($StartingDate != NULL) && ($EndingDate != NULL))
00316         {
00317             # select resources created between starting and ending dates
00318             $SearchStrings["Date Of Record Creation"] =
00319                     array(">=".$StartingDate, "<=".$EndingDate);
00320         }
00321         # else if begin date specified
00322         elseif ($StartingDate != NULL)
00323         {
00324             # select resources created after begin date
00325             $SearchStrings["Date Of Record Creation"] = ">=".$StartingDate;
00326         }
00327         # else if end date specified
00328         elseif ($EndingDate != NULL)
00329         {
00330             # select resources created after begin date
00331             $SearchStrings["Date Of Record Creation"] = "<=".$EndingDate;
00332         }
00333 
00334         # if set specified
00335         if ($Set != NULL)
00336         {
00337             # load set mappings
00338             $this->LoadSetNameInfo();
00339 
00340             # if set is valid
00341             if (isset($this->SetFields[$Set]))
00342             {
00343                 # add field spec to search strings
00344                 $SearchStrings[$this->SetFields[$Set]] = "= ".$this->SetValues[$Set];
00345             }
00346             else
00347             {
00348                 # set will not match anything so return empty array to caller
00349                 return array();
00350             }
00351         }
00352 
00353         # perform search for desired items
00354         $Engine = new SPTSearchEngine();
00355         if ($this->RetrievalSearchParameters)
00356         {  
00357             $SearchStrings = array_merge($SearchStrings, 
00358                     $this->RetrievalSearchParameters);
00359         }
00360         $SearchResults = $Engine->FieldedSearch($SearchStrings, 0, 1000000);
00361 
00362         # extract resource IDs from search results
00363         $ItemIds = array_keys($SearchResults);
00364 
00365         # return array of resource IDs to caller
00366         return $ItemIds;
00367     }
00368 
00369     # return array containing all set specs (with human-readable set names as keys)
00370     function GetListOfSets()
00371     {
00372         # make sure set name info is loaded
00373         $this->LoadSetNameInfo();
00374 
00375         # return list of sets to caller
00376         return $this->SetSpecs;
00377     }
00378 
00379     # retrieve IDs of items that match search parameters (only needed if OAI-SQ supported)
00380     function SearchForItems($SearchParams, $StartingDate = NULL, $EndingDate = NULL)
00381     {
00382         # translate field IDs into field names for search parameters
00383         $Schema = new MetadataSchema;
00384         foreach ($SearchParams as $FieldId => $Value)
00385         {
00386             if ($FieldId == "X-KEYWORD-X")
00387             {
00388                 $SearchStrings["XXXKeywordXXX"] = $Value;
00389             }
00390             else
00391             {
00392                 $Field = $Schema->GetField($FieldId);
00393                 $SearchStrings[$Field->Name()] = $Value;
00394             }
00395         }
00396 
00397         # add release flag requirement to search parameters
00398         $SearchStrings["Release Flag"] = "=1";
00399 
00400         # if both begin and end date supplied
00401         if (($StartingDate != NULL) && ($EndingDate != NULL))
00402         {
00403             # select resources created between starting and ending dates
00404             $SearchStrings["Date Of Record Creation"] =
00405                     array(">=".$StartingDate, "<=".$EndingDate);
00406         }
00407         # else if begin date specified
00408         elseif ($StartingDate != NULL)
00409         {
00410             # select resources created after begin date
00411             $SearchStrings["Date Of Record Creation"] = ">=".$StartingDate;
00412         }
00413         # else if end date specified
00414         elseif ($EndingDate != NULL)
00415         {
00416             # select resources created after begin date
00417             $SearchStrings["Date Of Record Creation"] = "<=".$EndingDate;
00418         }
00419 
00420         # perform search for desired items
00421         $Engine = new SPTSearchEngine();
00422         if ($this->RetrievalSearchParameters)
00423         {  
00424             $SearchStrings = array_merge($SearchStrings, 
00425                     $this->RetrievalSearchParameters);
00426         }
00427         $SearchResults = $Engine->FieldedSearch($SearchStrings, 0, 1000000);
00428 
00429         # save search scores
00430         $this->SearchScores = $SearchResults;
00431         $this->SearchScoreScale = $Engine->FieldedSearchWeightScale($SearchStrings);
00432 
00433         # extract resource IDs from search results
00434         $ItemIds = array_keys($SearchResults);
00435 
00436         # return array of resource IDs to caller
00437         return $ItemIds;
00438     }
00439 
00440 
00441     # ---- PRIVATE INTERFACE -------------------------------------------------
00442 
00443     var $SetSpecs;
00444     var $SetFields;
00445     var $SetValues;
00446     var $RetrievalSearchParameters;
00447     var $SearchScores;
00448     var $SearchScoreScale;
00449 
00450     # normalize value for use as an OAI set spec
00451     function NormalizeForSetSpec($Name)
00452     {
00453         return preg_replace("/[^a-zA-Z0-9\-_.!~*'()]/", "", $Name);
00454     }
00455 
00456     # load normalized set names and name mappings
00457     function LoadSetNameInfo()
00458     {
00459         # if set names have not already been loaded
00460         if (!isset($this->SetSpecs))
00461         {
00462             # start with empty list of sets
00463             $this->SetSpecs = array();
00464             $this->SetFields = array();
00465             $this->SetValues = array();
00466 
00467             # for each metadata field that is a type that can be used for sets
00468             $Schema = new MetadataSchema();
00469             $Fields = $Schema->GetFields(MetadataSchema::MDFTYPE_TREE|MetadataSchema::MDFTYPE_CONTROLLEDNAME|MetadataSchema::MDFTYPE_OPTION);
00470             foreach ($Fields as $Field)
00471             {
00472                 # if field is flagged as being used for OAI sets
00473                 if ($Field->UseForOaiSets())
00474                 {
00475                     # retrieve all possible values for field
00476                     $FieldValues = $Field->GetPossibleValues();
00477 
00478                     # prepend field name to each value and add to list of sets
00479                     $FieldName = $Field->Name();
00480                     $NormalizedFieldName = $this->NormalizeForSetSpec($FieldName);
00481                     foreach ($FieldValues as $Value)
00482                     {
00483                         $SetSpec = $NormalizedFieldName.":"
00484                                 .$this->NormalizeForSetSpec($Value);
00485                         $this->SetSpecs[$FieldName.": ".$Value] = $SetSpec;
00486                         $this->SetFields[$SetSpec] = $FieldName;
00487                         $this->SetValues[$SetSpec] = $Value;
00488                     }
00489                 }
00490             }
00491         }
00492     }
00493 }
00494 
00495 class SPTOAIItem extends OAIItem {
00496 
00497     # ---- PUBLIC INTERFACE --------------------------------------------------
00498 
00499     # object constructor
00500     function SPTOAIItem($ItemId, $SearchInfo = NULL)
00501     {
00502         # save ID for later use
00503         $this->Id = $ItemId;
00504 
00505         # save any search info supplied
00506         $this->SearchInfo = $SearchInfo;
00507 
00508         # attempt to create resource object
00509         $this->Resource = new Resource($ItemId);
00510 
00511         # if resource object creation failed
00512         if ($this->Resource->Status() == -1)
00513         {
00514             # set status to -1 to indicate constructor failure
00515             $this->LastStatus = -1;
00516         }
00517         else
00518         {
00519             # set status to 1 to indicate constructor success
00520             $this->LastStatus = 1;
00521 
00522             # if cumulative rating data is available for this resource
00523             global $SysConfig;
00524             if ($SysConfig->ResourceRatingsEnabled() 
00525                     && $this->Resource->CumulativeRating())
00526             {
00527                 # add cumulative rating data to search info
00528                 $this->SearchInfo["cumulativeRating"] = 
00529                         $this->Resource->CumulativeRating();
00530                 $this->SearchInfo["cumulativeRatingScale"] = 100;
00531             }
00532         }
00533     }
00534 
00535     function GetId() {  return $this->Id;  }
00536 
00537     function GetDatestamp()
00538     {
00539         $DateString = $this->Resource->Get("Date Of Record Creation");
00540         if ($DateString == "0000-00-00 00:00:00") {  $DateString = date("Y-m-d");  }
00541         $Date = new SPTDate($DateString);
00542         return $Date->FormattedISO8601();
00543     }
00544 
00545     function GetValue($ElementName)
00546     {
00547         # retrieve value
00548         $ReturnValue = $this->Resource->GetByFieldId($ElementName);
00549 
00550         # strip out any HTML tags if text value
00551         if (is_string($ReturnValue))
00552         {
00553             $ReturnValue = strip_tags($ReturnValue);
00554         }
00555 
00556         # format correctly if standardized date
00557         if ($this->GetQualifier($ElementName) == "W3C-DTF")
00558         {
00559             $Timestamp = strtotime($ReturnValue);
00560             $ReturnValue = date('Y-m-d\TH:i:s', $Timestamp)
00561                     .substr_replace(date('O', $Timestamp), ':', 3, 0);
00562         }
00563 
00564         # return value to caller
00565         return $ReturnValue;
00566     }
00567 
00568     function GetQualifier($ElementName)
00569     {
00570         $ReturnValue = NULL;
00571         $Qualifier = $this->Resource->GetQualifierByFieldId($ElementName, TRUE);
00572         if (is_array($Qualifier))
00573         {
00574             foreach ($Qualifier as $ItemId => $QualObj)
00575             {
00576                 if (is_object($QualObj))
00577                 {
00578                     $ReturnValue[$ItemId] = $QualObj->Name();
00579                 }
00580             }
00581         }
00582         else
00583         {
00584             if (isset($Qualifier) && is_object($Qualifier))
00585             {
00586                 $ReturnValue = $Qualifier->Name();
00587             }
00588         }
00589         return $ReturnValue;
00590     }
00591 
00592     function GetSets()
00593     {
00594         # start out with empty list
00595         $Sets = array();
00596 
00597         # for each possible metadata field
00598         $Schema = new MetadataSchema();
00599         $Fields = $Schema->GetFields(MetadataSchema::MDFTYPE_TREE|MetadataSchema::MDFTYPE_CONTROLLEDNAME|MetadataSchema::MDFTYPE_OPTION);
00600         foreach ($Fields as $Field)
00601         {
00602             # if field is flagged for use for OAI sets
00603             if ($Field->UseForOaiSets())
00604             {
00605                 # retrieve values for resource for this field and add to set list
00606                 $FieldName = $Field->Name();
00607                 $Values = $this->Resource->Get($FieldName);
00608                 if (isset($Values) && ($Values != NULL))
00609                 {
00610                     $NormalizedFieldName = $this->NormalizeForSetSpec($FieldName);
00611                     if (is_array($Values) && count($Values))
00612                     {
00613                         foreach ($Values as $Value)
00614                         {
00615                             $Sets[] = $NormalizedFieldName.":"
00616                                     .$this->NormalizeForSetSpec($Value);
00617                         }
00618                     }
00619                     else
00620                     {
00621                         $Sets[] = $NormalizedFieldName.":"
00622                                 .$this->NormalizeForSetSpec($Values);
00623                     }
00624                 }
00625             }
00626         }
00627 
00628         # return list of sets to caller
00629         return $Sets;
00630     }
00631 
00632     function GetSearchInfo()
00633     {
00634         return $this->SearchInfo;
00635     }
00636 
00637     function Status()
00638     {
00639         return $this->LastStatus;
00640     }
00641 
00642 
00643     # ---- PRIVATE INTERFACE -------------------------------------------------
00644 
00645     var $Id;
00646     var $Resource;
00647     var $LastStatus;
00648     var $SearchInfo;
00649 
00650     # normalize value for use as an OAI set spec
00651     function NormalizeForSetSpec($Name)
00652     {
00653         return preg_replace("/[^a-zA-Z0-9\-_.!~*'()]/", "", $Name);
00654     }
00655 }
00656 
00657 
00658 ?>
CWIS logo doxygen
Copyright 2009 Internet Scout