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

CWIS logo doxygen
Copyright 2010 Internet Scout