Search:

CWIS Developers Documentation

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

ResourceFactory.php

Go to the documentation of this file.
00001 <?PHP
00002 
00003 #
00004 #   FILE:  SPT--ResourceFactory.php
00005 #
00006 #   METHODS PROVIDED:
00007 #       ResourceFactory()
00008 #           - constructor
00009 #       DuplicateResource($ResourceId)
00010 #           - create duplicate resource and return to caller
00011 #       (SEE ALSO:  SPT--ItemFactory.php)
00012 #
00013 #   AUTHOR:  Edward Almasy
00014 #
00015 #   Part of the Scout Portal Toolkit
00016 #   Copyright 2003 Internet Scout Project
00017 #   http://scout.wisc.edu
00018 #
00019 
00020 
00021 class ResourceFactory extends ItemFactory {
00022 
00023     # ---- PUBLIC INTERFACE --------------------------------------------------
00024 
00025     # object constructor
00026     function ResourceFactory()
00027     {
00028         # set up item factory base class
00029         $this->ItemFactory("Resource", "Resources", "ResourceId");
00030     }
00031 
00032     # create duplicate resource and return to caller
00033     function DuplicateResource($ResourceId)
00034     {
00035         # create new target resource
00036         $DstResource = new Resource();
00037 
00038         # load up resource to duplicate
00039         $SrcResource = new Resource($ResourceId);
00040 
00041         # if resource to duplicate was found
00042         if ($SrcResource->Status() > 0)
00043         {
00044             # for each metadata field
00045             $Schema = new MetadataSchema();
00046             $Fields = $Schema->GetFields();
00047             foreach ($Fields as $Field)
00048             {
00049                 # copy values from old resource to new resource (except for cumulative rating)
00050                 if ($Field->Name() != "Cumulative Rating")
00051                 {
00052                     $DstResource->SetByField($Field, $SrcResource->GetByField($Field, TRUE));
00053                 }
00054             }
00055         }
00056 
00057         # return new resource to caller
00058         return $DstResource;
00059     }
00060 
00061     # clear or change specific qualifier for all resources
00062     function ClearQualifier($ObjectOrId, $NewObjectOrId = NULL)
00063     {
00064         # sanitize qualifier ID or retrieve from object
00065         $QualifierId = is_object($ObjectOrId)
00066                 ?  $ObjectOrId->Id() : intval($ObjectOrId);
00067 
00068         # if new qualifier passed in
00069         if ($NewObjectOrId !== NULL)
00070         {
00071             # sanitize qualifier ID to change to or retrieve it from object
00072             $NewQualifierIdVal = is_object($NewObjectOrId)
00073                     ?  $NewObjectOrId->Id() : intval($NewObjectOrId);
00074         }
00075         else
00076         {
00077             # qualifier should be cleared
00078             $NewQualifierIdVal = "NULL";
00079         }
00080 
00081         # for each metadata field
00082         $Schema = new MetadataSchema();
00083         $Fields = $Schema->GetFields();
00084         foreach ($Fields as $Field)
00085         {
00086             # if field uses qualifiers and uses item-level qualifiers
00087             $QualColName = $Field->DBFieldName()."Qualifier";
00088             if ($Field->UsesQualifiers()
00089                 && $Field->HasItemLevelQualifiers()
00090                 && $this->DB->FieldExists("Resources", $QualColName))
00091             {
00092                 # set all occurrences to new qualifier value
00093                 $this->DB->Query("UPDATE Resources"
00094                            ." SET ".$QualColName." = ".$NewQualifierIdVal.""
00095                            ." WHERE ".$QualColName." = '".$QualifierId."'");
00096             }
00097         }
00098 
00099         # clear or change qualifier association with controlled names
00100         # (NOTE: this should probably be done in a controlled name factory object)
00101         $this->DB->Query("UPDATE ControlledNames"
00102                    ." SET QualifierId = ".$NewQualifierIdVal
00103                    ." WHERE QualifierId = '".$QualifierId."'");
00104 
00105         # clear or change qualifier association with classifications
00106         # (NOTE: this should probably be done in a classification factory object)
00107         $this->DB->Query("UPDATE Classifications"
00108                    ." SET QualifierId = ".$NewQualifierIdVal
00109                    ." WHERE QualifierId = '".$QualifierId."'");
00110     }
00111 
00112     # return count of rated resources
00113     function GetRatedResourceCount()
00114     {
00115         $RatedResourceCount = $this->DB->Query(
00116                 "SELECT COUNT(DISTINCT ResourceId) AS ResourceCount "
00117                 ."FROM ResourceRatings", "ResourceCount");
00118         return $RatedResourceCount;
00119     }
00120 
00121     # return count of users who have rated resources
00122     function GetRatedResourceUserCount()
00123     {
00124         $RatedResourceCount = $this->DB->Query(
00125                 "SELECT COUNT(DISTINCT UserId) AS UserCount "
00126                 ."FROM ResourceRatings", "UserCount");
00127         return $RatedResourceCount;
00128     }
00129 
00130     # return recently released resources
00131     function GetRecentlyReleasedResources($Count = 10, $Offset = 0, $MaxDaysToGoBack = 90)
00132     {
00133         # assume that no resources will be found
00134         $Resources = array();
00135 
00136         # calculate cutoff date for resources
00137         $CutoffDate = date("Y-m-d H:i:s", strtotime($MaxDaysToGoBack." days ago"));
00138 
00139         # query for resource IDs
00140         $this->DB->Query("SELECT ResourceId FROM Resources WHERE"
00141                 ." DateOfRecordRelease > '".$CutoffDate."'"
00142                 ." AND ReleaseFlag = 1"
00143                 ." AND ResourceId >= 0"
00144                 ." ORDER BY DateOfRecordRelease DESC, DateOfRecordCreation DESC"
00145                 ." LIMIT ".intval($Offset).", ".intval($Count));
00146         $ResourceIds = $this->DB->FetchColumn("ResourceId");
00147 
00148         # for each resource ID found
00149         foreach ($ResourceIds as $ResourceId)
00150         {
00151             # load resource and add to list of found resources
00152             $Resources[$ResourceId] = new Resource($ResourceId);
00153         }
00154 
00155         # return found resources to caller
00156         return $Resources;
00157     }
00158 
00159     # return resources sorted by specified field
00160     function GetResourceIdsSortedBy($FieldName, $Ascending = TRUE, $Limit = NULL)
00161     {
00162         # assume no resources will be found
00163         $ResourceIds = array();
00164 
00165         # get field
00166         $Schema = new MetadataSchema();
00167         $Field = $Schema->GetFieldByName($FieldName);
00168 
00169         # if field was found
00170         if ($Field != NULL)
00171         {
00172             # construct query based on field type
00173             switch ($Field->Type())
00174             {
00175                 case MetadataSchema::MDFTYPE_TEXT:
00176                 case MetadataSchema::MDFTYPE_PARAGRAPH:
00177                 case MetadataSchema::MDFTYPE_URL:
00178                     $Count = $this->DB->Query("SELECT COUNT(*) AS ResourceCount"
00179                             ." FROM Resources WHERE "
00180                             .$Field->DBFieldName()." IS NOT NULL"
00181                             ." AND LENGTH(LTRIM(RTRIM(".$Field->DBFieldName()."))) > 0",
00182                             "ResourceCount");
00183                     if ($Count > 1)
00184                     {
00185                         $Query = "SELECT ResourceId FROM Resources"
00186                                 ." ORDER BY ".$Field->DBFieldName()
00187                                 .($Ascending ? " ASC" : " DESC");
00188                     }
00189                     break;
00190 
00191                 case MetadataSchema::MDFTYPE_NUMBER:
00192                 case MetadataSchema::MDFTYPE_TIMESTAMP:
00193                     $Count = $this->DB->Query("SELECT COUNT(*) AS ResourceCount"
00194                             ." FROM Resources WHERE "
00195                             .$Field->DBFieldName()." IS NOT NULL",
00196                             "ResourceCount");
00197                     if ($Count > 1)
00198                     {
00199                         $Query = "SELECT ResourceId FROM Resources"
00200                                 ." ORDER BY ".$Field->DBFieldName()
00201                                 .($Ascending ? " ASC" : " DESC");
00202                     }
00203                     break;
00204 
00205                 case MetadataSchema::MDFTYPE_DATE:
00206                     $Count = $this->DB->Query("SELECT COUNT(*) AS ResourceCount"
00207                             ." FROM Resources WHERE "
00208                             .$Field->DBFieldName()."Begin IS NOT NULL",
00209                             "ResourceCount");
00210                     if ($Count > 1)
00211                     {
00212                         $Query = "SELECT ResourceId FROM Resources"
00213                                 ." ORDER BY ".$Field->DBFieldName()."Begin"
00214                                 .($Ascending ? " ASC" : " DESC");
00215                     }
00216                     break;
00217             }
00218 
00219             # if appropriate query was found
00220             if (isset($Query))
00221             {
00222                 # if limited number of results were requested
00223                 if ($Limit !== NULL)
00224                 {
00225                     # add limit to query
00226                     $Query .= " LIMIT ".intval($Limit);
00227                 }
00228 
00229                 # perform query and retrieve resource IDs
00230                 $this->DB->Query($Query);
00231                 $ResourceIds = $this->DB->FetchColumn("ResourceId");
00232             }
00233         }
00234 
00235         # return resource IDs to caller
00236         return $ResourceIds;
00237     }
00238 
00239     # get date/time of last resource modification (returned as Unix timestamp)
00240     function GetTimestampOfLastResourceModification($OnlyReleasedResources = TRUE)
00241     {
00242         $LastChangeDate = $this->DB->Query(
00243                 "SELECT MAX(DateLastModified) AS LastChangeDate"
00244                 ." FROM Resources".($OnlyReleasedResources ? " WHERE ReleaseFlag = 1" : ""),
00245                 "LastChangeDate");
00246         return ($LastChangeDate ? strtotime($LastChangeDate) : NULL);
00247     }
00248 
00249     # get list of possible field names for resources
00250     function GetPossibleFieldNames()
00251     {
00252         # retrieve field names from schema
00253         $FieldNames = array();
00254         $Schema = new MetadataSchema();
00255         $Fields = $Schema->GetFields();
00256         foreach ($Fields as $Field)
00257         {
00258             $FieldNames[$Field->Id()] = $Field->Name();
00259         }
00260 
00261         # return field names to caller
00262         return $FieldNames;
00263     }
00264 
00265     # find resources with values that match those specified
00266     # (index of $ValuesToMatch is field IDs)
00267     function GetMatchingResources($ValuesToMatch)
00268     {
00269         # start out assuming we won't find any resources
00270         $Resources = array();
00271 
00272         # for each value
00273         $Schema = new MetadataSchema();
00274         $Fields = $Schema->GetFields(
00275                 MetadataSchema::MDFTYPE_TEXT |
00276                 MetadataSchema::MDFTYPE_PARAGRAPH |
00277                 MetadataSchema::MDFTYPE_NUMBER | MetadataSchema::MDFTYPE_DATE |
00278                 MetadataSchema::MDFTYPE_TIMESTAMP |
00279                 MetadataSchema::MDFTYPE_FLAG | MetadataSchema::MDFTYPE_URL |
00280                 MetadataSchema::MDFTYPE_POINT);
00281         $LinkingTerm = "";
00282         $Condition = "";
00283         foreach ($ValuesToMatch as $FieldId => $Value)
00284         {
00285             # if field can be used for comparison
00286             if (isset($Fields[$FieldId]))
00287             {
00288                 # add comparison to condition
00289                 $Condition .= $LinkingTerm.$Fields[$FieldId]->DBFieldName()
00290                         ." = '".addslashes($Value)."'";
00291                 $LinkingTerm = " AND ";
00292             }
00293         }
00294 
00295         # if there were valid conditions
00296         if (strlen($Condition))
00297         {
00298             # build query statment
00299             $Query = "SELECT ResourceId FROM Resources WHERE ".$Condition;
00300 
00301             # execute query to retrieve matching resource IDs
00302             $this->DB->Query($Query);
00303             $ResourceIds = $DB->FetchColumn("ResourceId");
00304 
00305             # retrieve resource objects
00306             foreach ($ResourceIds as $Id)
00307             {
00308                 $Resources[$Id] = new Resource($Id);
00309             }
00310         }
00311 
00312         # return any resources found to caller
00313         return $Resources;
00314     }
00315 
00316 
00317     # ---- PRIVATE INTERFACE -------------------------------------------------
00318 
00319 }
00320 
00321 
00322 ?>
CWIS logo doxygen
Copyright 2009 Internet Scout