MetadataField.php

Go to the documentation of this file.
00001 <?PHP
00002 
00003 #
00004 #   FILE:  MetadataField.php
00005 #
00006 #   Part of the Collection Workflow Integration System
00007 #   Copyright 2002-2010 Internet Scout
00008 #   http://scout.wisc.edu
00009 #
00010 
00011 class MetadataField {
00012 
00013     # ---- PUBLIC INTERFACE --------------------------------------------------
00014 
00015     # Update methods for timestamp fields
00016     const UPDATEMETHOD_NOAUTOUPDATE   = "NoAutoUpdate";
00017     const UPDATEMETHOD_ONRECORDCREATE = "OnRecordCreate";
00018     const UPDATEMETHOD_BUTTON         = "Button";
00019     const UPDATEMETHOD_ONRECORDEDIT   = "OnRecordEdit";
00020     const UPDATEMETHOD_ONRECORDCHANGE = "OnRecordChange";
00021 
00022     # get current error status of object
00023     function Status() {  return $this->ErrorStatus;  }
00024 
00025     # get/set type of field as enumerated value
00026     function Type($NewValue = DB_NOVALUE)
00027     {
00028         # if new value supplied
00029         if (($NewValue != DB_NOVALUE)
00030              && ($NewValue != MetadataField::$FieldTypePHPEnums[$this->DBFields["FieldType"]]))
00031         {
00032             # update database fields and store new type
00033             $this->ModifyField(NULL, $NewValue);
00034         }
00035 
00036         # return type to caller
00037         return MetadataField::$FieldTypePHPEnums[$this->DBFields["FieldType"]];
00038     }
00039 
00040     # get type of field as type name (string)
00041     function TypeAsName()
00042     {
00043         return $this->DBFields["FieldType"];
00044     }
00045 
00046     # get/set name of field
00047     function Name($NewName = DB_NOVALUE)
00048     {
00049         # if new name specified
00050         if (($NewName != DB_NOVALUE)
00051             && (trim($NewName) != $this->DBFields["FieldName"]))
00052         {
00053             # if field name is invalid
00054             $NewName = trim($NewName);
00055             if ( !preg_match("/^[[:alnum:] ]+$/", $NewName) )
00056             {
00057                 # set error status to indicate illegal name
00058                 $this->ErrorStatus = MetadataSchema::MDFSTAT_ILLEGALNAME;
00059             }
00060             else
00061             {
00062                 # check for duplicate name
00063                 $DuplicateCount = $this->DB->Query("SELECT COUNT(*) AS RecordCount FROM MetadataFields "
00064                                              ."WHERE FieldName = '".addslashes($NewName)."'",
00065                                              "RecordCount");
00066 
00067                 # if field name is duplicate
00068                 if ($DuplicateCount > 0)
00069                 {
00070                     # set error status to indicate duplicate name
00071                     $this->ErrorStatus = MetadataSchema::MDFSTAT_DUPLICATENAME;
00072                 }
00073                 else
00074                 {
00075                     # modify database declaration to reflect new field name
00076                     $this->ErrorStatus = MetadataSchema::MDFSTAT_OK;
00077                     $this->ModifyField($NewName);
00078                 }
00079             }
00080         }
00081 
00082         # return value to caller
00083         return $this->DBFields["FieldName"];
00084     }
00085 
00086     # get associative array (enumeration => string) containing field types we can convert to
00087     function GetAllowedConversionTypes()
00088     {
00089         # determine type list based on our type
00090         switch ($this->Type())
00091         {
00092         case MetadataSchema::MDFTYPE_TEXT:
00093         case MetadataSchema::MDFTYPE_PARAGRAPH:
00094         case MetadataSchema::MDFTYPE_NUMBER:
00095         case MetadataSchema::MDFTYPE_FLAG:
00096         case MetadataSchema::MDFTYPE_URL:
00097             $AllowedTypes = array(
00098                 MetadataSchema::MDFTYPE_TEXT       => "Text",
00099                 MetadataSchema::MDFTYPE_PARAGRAPH  => "Paragraph",
00100                 MetadataSchema::MDFTYPE_NUMBER     => "Number",
00101                 MetadataSchema::MDFTYPE_FLAG       => "Flag",
00102                 MetadataSchema::MDFTYPE_URL        => "Url"
00103                 );
00104             break;
00105 
00106         case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00107         case MetadataSchema::MDFTYPE_OPTION:
00108             $AllowedTypes = array(
00109                 MetadataSchema::MDFTYPE_CONTROLLEDNAME => "ControlledName",
00110                 MetadataSchema::MDFTYPE_OPTION         => "Option",
00111                 );
00112             break;
00113 
00114         case MetadataSchema::MDFTYPE_DATE:
00115             $AllowedTypes = array(
00116                 MetadataSchema::MDFTYPE_TEXT  => "Text",
00117                 MetadataSchema::MDFTYPE_DATE  => "Date",
00118                 );
00119             break;
00120 
00121         case MetadataSchema::MDFTYPE_IMAGE:
00122             $AllowedTypes = array(
00123                 MetadataSchema::MDFTYPE_TEXT  => "Text",
00124                 MetadataSchema::MDFTYPE_IMAGE => "Still Image",
00125                 );
00126             break;
00127 
00128         case MetadataSchema::MDFTYPE_TIMESTAMP:
00129         case MetadataSchema::MDFTYPE_TREE:
00130         case MetadataSchema::MDFTYPE_USER:
00131         case MetadataSchema::MDFTYPE_FILE:
00132         default:
00133             $AllowedTypes = array();
00134             break;
00135         }
00136 
00137         # return type list to caller
00138         return $AllowedTypes;
00139     }
00140 
00141     # get/set whether item is temporary instance
00142     function IsTempItem($NewSetting = NULL)
00143     {
00144         $ItemTableName = "MetadataFields";
00145         $ItemIdFieldName = "FieldId";
00146         $ItemFactoryObjectName = "MetadataSchema";
00147         $ItemAssociationTables = array(
00148                 "FieldQualifierInts",
00149                 );
00150         $ItemAssociationFieldName = "MetadataFieldId";
00151 
00152         # if new temp item setting supplied
00153         if ($NewSetting !== NULL)
00154         {
00155             # if caller requested to switch
00156             if ((($this->Id() < 0) && ($NewSetting == FALSE))
00157                     || (($this->Id() >= 0) && ($NewSetting == TRUE)))
00158             {
00159                 # if field name is invalid
00160                 if (strlen($this->NormalizeFieldNameForDB($this->Name())) < 1)
00161                 {
00162                     # set error status to indicate illegal name
00163                     $this->ErrorStatus = MetadataSchema::MDFSTAT_ILLEGALNAME;
00164                 }
00165                 else
00166                 {
00167                     # lock DB tables to prevent next ID from being grabbed
00168                     $DB = $this->DB;
00169                     $DB->Query("LOCK TABLES ".$ItemTableName." WRITE,".
00170                             "APSessions WRITE, APSessionData WRITE");
00171 
00172                     # get next temp item ID
00173                     $OldItemId = $this->Id();
00174                     $Factory = new $ItemFactoryObjectName();
00175                     if ($NewSetting == TRUE)
00176                     {
00177                         $NewId = $Factory->GetNextTempItemId();
00178                     }
00179                     else
00180                     {
00181                         $NewId = $Factory->GetNextItemId();
00182                     }
00183 
00184                     # change item ID
00185                     $DB->Query("UPDATE ".$ItemTableName." SET ".$ItemIdFieldName." = ".
00186                         $NewId.  " WHERE ".$ItemIdFieldName." = ".$OldItemId);
00187 
00188                     # release DB tables
00189                     $DB->Query("UNLOCK TABLES");
00190 
00191                     # change associations
00192                     foreach ($ItemAssociationTables as $TableName)
00193                     {
00194                         $DB->Query("UPDATE ".$TableName." SET ".$ItemAssociationFieldName." = ".
00195                                 $NewId.  " WHERE ".$ItemAssociationFieldName." = ".$OldItemId);
00196                     }
00197 
00198                     # if changing item from temp to non-temp
00199                     if ($NewSetting == FALSE)
00200                     {
00201                         # add any needed database fields and/or entries
00202                         $this->AddDatabaseFields();
00203                     }
00204 
00205                     # update metadata field id
00206                     $this->DBFields["FieldId"] = $NewId;
00207                 }
00208             }
00209         }
00210 
00211         # report to caller whether we are a temp item
00212         return ($this->Id() < 0) ? TRUE : FALSE;
00213     }
00214 
00215     # get field attributes
00216     function Id() {  return $this->DBFields["FieldId"];  }
00217     function DBFieldName() {  return $this->DBFields["DBFieldName"];  }
00218 
00219     # get/set field attributes
00220     function Description($NewValue = DB_NOVALUE) {  return $this->UpdateValue("Description", $NewValue);  }
00221     function RequiredBySPT($NewValue = DB_NOVALUE) {  return $this->UpdateValue("RequiredBySPT", $NewValue);  }
00222     function Enabled($NewValue = DB_NOVALUE) {  return $this->UpdateValue("Enabled", $NewValue);  }
00223     function Optional($NewValue = DB_NOVALUE) {  return $this->UpdateValue("Optional", $NewValue);  }
00224     function Viewable($NewValue = DB_NOVALUE) {  return $this->UpdateValue("Viewable", $NewValue);  }
00225     function AllowMultiple($NewValue = DB_NOVALUE) {  return $this->UpdateValue("AllowMultiple", $NewValue);  }
00226     function IncludeInKeywordSearch($NewValue = DB_NOVALUE) {  return $this->UpdateValue("IncludeInKeywordSearch", $NewValue);  }
00227     function IncludeInAdvancedSearch($NewValue = DB_NOVALUE) {  return $this->UpdateValue("IncludeInAdvancedSearch", $NewValue);  }
00228     function IncludeInSortOptions($NewValue = DB_NOVALUE) {  return $this->UpdateValue("IncludeInSortOptions", $NewValue);  }
00229     function IncludeInRecommenderSystem($NewValue = DB_NOVALUE) {  return $this->UpdateValue("IncludeInRecommenderSystem", $NewValue);  }
00230     function TextFieldSize($NewValue = DB_NOVALUE) {  return $this->UpdateValue("TextFieldSize", $NewValue);  }
00231     function MaxLength($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxLength", $NewValue);  }
00232     function ParagraphRows($NewValue = DB_NOVALUE) {  return $this->UpdateValue("ParagraphRows", $NewValue);  }
00233     function ParagraphCols($NewValue = DB_NOVALUE) {  return $this->UpdateValue("ParagraphCols", $NewValue);  }
00234     function MinValue($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MinValue", $NewValue);  }
00235     function MaxValue($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxValue", $NewValue);  }
00236     function FlagOnLabel($NewValue = DB_NOVALUE) {  return $this->UpdateValue("FlagOnLabel", $NewValue);  }
00237     function FlagOffLabel($NewValue = DB_NOVALUE) {  return $this->UpdateValue("FlagOffLabel", $NewValue);  }
00238     function DateFormat($NewValue = DB_NOVALUE) {  return $this->UpdateValue("DateFormat", $NewValue);  }
00239     function SearchWeight($NewValue = DB_NOVALUE) {  return $this->UpdateValue("SearchWeight", $NewValue);  }
00240     function RecommenderWeight($NewValue = DB_NOVALUE) {  return $this->UpdateValue("RecommenderWeight", $NewValue);  }
00241     function MaxHeight($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxHeight", $NewValue);  }
00242     function MaxWidth($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxWidth", $NewValue);  }
00243     function MaxPreviewHeight($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxPreviewHeight", $NewValue);  }
00244     function MaxPreviewWidth($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxPreviewWidth", $NewValue);  }
00245     function MaxThumbnailHeight($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxThumbnailHeight", $NewValue);  }
00246     function MaxThumbnailWidth($NewValue = DB_NOVALUE) {  return $this->UpdateValue("MaxThumbnailWidth", $NewValue);  }
00247     function DefaultAltText($NewValue = DB_NOVALUE) {  return $this->UpdateValue("DefaultAltText", $NewValue);  }
00248     function ImagePreviewPrivilege($NewValue = DB_NOVALUE) {  return $this->UpdateValue("ImagePreviewPrivilege", $NewValue);  }
00249     function UsesQualifiers($NewValue = DB_NOVALUE) {  return $this->UpdateValue("UsesQualifiers", $NewValue);  }
00250     function ShowQualifiers($NewValue = DB_NOVALUE) {  return $this->UpdateValue("ShowQualifiers", $NewValue);  }
00251     function DefaultQualifier($NewValue = DB_NOVALUE) {  return $this->UpdateValue("DefaultQualifier", $NewValue);  }
00252     function UseForOaiSets($NewValue = DB_NOVALUE) {  return $this->UpdateValue("UseForOaiSets", $NewValue);  }
00253     function ViewingPrivilege($NewValue = DB_NOVALUE) {  return $this->UpdateValue("ViewingPrivilege", $NewValue);  }
00254     function AuthoringPrivilege($NewValue = DB_NOVALUE) {  return $this->UpdateValue("AuthoringPrivilege", $NewValue);  }
00255     function EditingPrivilege($NewValue = DB_NOVALUE) {  return $this->UpdateValue("EditingPrivilege", $NewValue);  }
00256     function AllowHTML($NewValue = DB_NOVALUE) {  return $this->UpdateValue("AllowHTML", $NewValue);  }
00257     function TreeBrowsingPrivilege($NewValue = DB_NOVALUE) {  return $this->UpdateValue("TreeBrowsingPrivilege", $NewValue);  }
00258 
00259     function PointPrecision($NewValue = DB_NOVALUE)
00260     {
00261         if ($NewValue !== DB_NOVALUE && $this->Id() >= 0)
00262         {
00263             $OldValue = $this->UpdateValue("PointPrecision", DB_NOVALUE);
00264 
00265             if ($NewValue != $OldValue)
00266             {
00267                 $Decimals  = $this->UpdateValue("PointDecimalDigits", DB_NOVALUE);
00268 
00269                 $TotalDigits = $NewValue + $Decimals;
00270 
00271 
00272                 $this->DB->Query("ALTER TABLE Resources MODIFY COLUMN "
00273                            ."`".$this->DBFields["DBFieldName"]."X` "
00274                            ."DECIMAL(".$TotalDigits.",".$Decimals.")");
00275                 $this->DB->Query("ALTER TABLE Resources MODIFY COLUMN "
00276                            ."`".$this->DBFields["DBFieldName"]."Y` "
00277                            ."DECIMAL(".$TotalDigits.",".$Decimals.")");
00278             }
00279         }
00280 
00281         return $this->UpdateValue("PointPrecision", $NewValue);
00282     }
00283 
00284     function PointDecimalDigits($NewValue = DB_NOVALUE)
00285     {
00286         if ($NewValue !== DB_NOVALUE && $this->Id() >= 0)
00287         {
00288             $OldValue = $this->UpdateValue("PointDecimalDigits", DB_NOVALUE);
00289 
00290             if ($NewValue != $OldValue)
00291             {
00292                 $Precision = $this->UpdateValue("PointPrecision", DB_NOVALUE);
00293 
00294                 $TotalDigits = $NewValue + $Precision;
00295 
00296                 $this->DB->Query("ALTER TABLE Resources MODIFY COLUMN "
00297                            ."`".$this->DBFields["DBFieldName"]."X` "
00298                            ."DECIMAL(".$TotalDigits.",".$NewValue.")");
00299                 $this->DB->Query("ALTER TABLE Resources MODIFY COLUMN "
00300                            ."`".$this->DBFields["DBFieldName"]."Y` "
00301                            ."DECIMAL(".$TotalDigits.",".$NewValue.")");
00302             }
00303         }
00304 
00305         return $this->UpdateValue("PointDecimalDigits", $NewValue);
00306     }
00307 
00308     function DefaultValue($NewValue = DB_NOVALUE)
00309     {
00310         if ($this->Type() == MetadataSchema::MDFTYPE_POINT)
00311         {
00312             if ($NewValue !== DB_NOVALUE &&
00313                 isset($NewValue["X"]) && isset($NewValue["Y"]))
00314             {
00315                 $NewValue = $NewValue["X"].",".$NewValue["Y"];
00316             }
00317 
00318             $tmp = explode(",", $this->UpdateValue("DefaultValue", $NewValue));
00319 
00320             if (count($tmp)==2)
00321             {
00322                 $rc = array("X" => $tmp[0], "Y" => $tmp[1]);
00323             }
00324             else
00325             {
00326                 $rc = array("X" => NULL, "Y" => NULL);
00327             }
00328         }
00329         else
00330         {
00331             $rc = $this->UpdateValue("DefaultValue", $NewValue);
00332         }
00333         return $rc;
00334     }
00335 
00341     function UpdateMethod($NewValue = DB_NOVALUE)
00342     {
00343         return $this->UpdateValue("UpdateMethod", $NewValue);
00344     }
00345 
00346     # get possible values (only meaningful for Trees, Controlled Names, Options, Flags)
00347     # (index for returned array is IDs for values)
00348     function GetPossibleValues($MaxNumberOfValues = NULL, $Offset=0)
00349     {
00350         # retrieve values based on field type
00351         switch ($this->Type())
00352         {
00353             case MetadataSchema::MDFTYPE_TREE:
00354                 $QueryString = "SELECT ClassificationId, ClassificationName"
00355                         ." FROM Classifications WHERE FieldId = ".$this->Id()
00356                         ." ORDER BY ClassificationName";
00357                 if ($MaxNumberOfValues)
00358                 {
00359                     $QueryString .= " LIMIT ".intval($MaxNumberOfValues)." OFFSET "
00360                         .intval($Offset);
00361                 }
00362                 $this->DB->Query($QueryString);
00363                 $PossibleValues = $this->DB->FetchColumn(
00364                         "ClassificationName", "ClassificationId");
00365                 break;
00366 
00367             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00368             case MetadataSchema::MDFTYPE_OPTION:
00369                 $QueryString = "SELECT ControlledNameId, ControlledName"
00370                         ." FROM ControlledNames WHERE FieldId = ".$this->Id()
00371                         ." ORDER BY ControlledName";
00372                 if ($MaxNumberOfValues)
00373                 {
00374                     $QueryString .= " LIMIT ".intval($MaxNumberOfValues)." OFFSET "
00375                         .intval($Offset);
00376                 }
00377                 $this->DB->Query($QueryString);
00378                 $PossibleValues = $this->DB->FetchColumn(
00379                         "ControlledName", "ControlledNameId");
00380                 break;
00381 
00382             case MetadataSchema::MDFTYPE_FLAG:
00383                 $PossibleValues[0] = $this->FlagOffLabel();
00384                 $PossibleValues[1] = $this->FlagOnLabel();
00385                 break;
00386 
00387             default:
00388                 # for everything else return an empty array
00389                 $PossibleValues = array();
00390                 break;
00391         }
00392 
00393         # return array of possible values to caller
00394         return $PossibleValues;
00395     }
00396 
00397     # get count of possible values (only meaningful for Trees, Controlled Names, Options)
00398     function GetCountOfPossibleValues()
00399     {
00400         # retrieve values based on field type
00401         switch ($this->Type())
00402         {
00403             case MetadataSchema::MDFTYPE_TREE:
00404                 $Count = $this->DB->Query("SELECT count(*) AS ValueCount"
00405                         ." FROM Classifications WHERE FieldId = ".$this->Id(),
00406                         "ValueCount");
00407                 break;
00408 
00409             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00410             case MetadataSchema::MDFTYPE_OPTION:
00411                 $Count = $this->DB->Query("SELECT count(*) AS ValueCount"
00412                         ." FROM ControlledNames WHERE FieldId = ".$this->Id(),
00413                         "ValueCount");
00414                 break;
00415 
00416             case MetadataSchema::MDFTYPE_FLAG:
00417                 $Count = 2;
00418                 break;
00419 
00420             default:
00421                 # for everything else return an empty array
00422                 $Count = 0;
00423                 break;
00424         }
00425 
00426         # return count of possible values to caller
00427         return $Count;
00428     }
00429 
00430     # get ID for specified value (only meaningful for Trees / Controlled Names / Options)
00431     # (returns NULL if value not found)
00432     function GetIdForValue($Value)
00433     {
00434         # retrieve ID based on field type
00435         switch ($this->Type())
00436         {
00437             case MetadataSchema::MDFTYPE_TREE:
00438                 $Id = $this->DB->Query("SELECT ClassificationId FROM Classifications"
00439                         ." WHERE ClassificationName = '".addslashes($Value)."'"
00440                         ." AND FieldId = ".$this->Id(),
00441                         "ClassificationId");
00442                 break;
00443 
00444             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00445             case MetadataSchema::MDFTYPE_OPTION:
00446                 $Id = $this->DB->Query("SELECT ControlledNameId FROM ControlledNames"
00447                         ." WHERE ControlledName = '".addslashes($Value)."'"
00448                         ." AND FieldId = ".$this->Id(),
00449                         "ControlledNameId");
00450                 break;
00451 
00452             default:
00453                 # for everything else return NULL
00454                 $Id = NULL;
00455                 break;
00456         }
00457 
00458         # return ID for value to caller
00459         return $Id;
00460     }
00461 
00462     # get value for specified ID (only meaningful for Trees / Controlled Names / Options)
00463     # (returns NULL if ID not found)
00464     function GetValueForId($Id)
00465     {
00466         # retrieve ID based on field type
00467         switch ($this->Type())
00468         {
00469             case MetadataSchema::MDFTYPE_TREE:
00470                 $Value = $this->DB->Query("SELECT ClassificationName FROM Classifications"
00471                         ." WHERE ClassificationId = '".intval($Id)."'"
00472                         ." AND FieldId = ".$this->Id(),
00473                         "ClassificationName");
00474                 break;
00475 
00476             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00477             case MetadataSchema::MDFTYPE_OPTION:
00478                 $Value = $this->DB->Query("SELECT ControlledName FROM ControlledNames"
00479                         ." WHERE ControlledNameId = '".intval($Id)."'"
00480                         ." AND FieldId = ".$this->Id(),
00481                         "ControlledName");
00482                 break;
00483 
00484             default:
00485                 # for everything else return NULL
00486                 $Value = NULL;
00487                 break;
00488         }
00489 
00490         # return ID for value to caller
00491         return $Value;
00492     }
00493 
00494 
00495 
00496     # get/set whether field uses item-level qualifiers
00497     function HasItemLevelQualifiers($NewValue = DB_NOVALUE)
00498     {
00499         # if value provided different from present value
00500         if (($NewValue != DB_NOVALUE)
00501             && ($NewValue != $this->DBFields["HasItemLevelQualifiers"]))
00502         {
00503             # check if qualifier column currently exists
00504             $QualColName = $this->DBFieldName()."Qualifier";
00505             $QualColExists = $this->DB->FieldExists("Resources", $QualColName);
00506 
00507             # if new value indicates qualifiers should now be used
00508             if ($NewValue == TRUE)
00509             {
00510                 # if qualifier column does not exist in DB for this field
00511                 if ($QualColExists == FALSE)
00512                 {
00513                     # add qualifier column in DB for this field
00514                     $this->DB->Query("ALTER TABLE Resources ADD COLUMN `"
00515                                      .$QualColName."` INT");
00516                 }
00517             }
00518             else
00519             {
00520                 # if qualifier column exists in DB for this field
00521                 if ($QualColExists == TRUE)
00522                 {
00523                     # remove qualifier column from DB for this field
00524                     $this->DB->Query("ALTER TABLE Resources DROP COLUMN `"
00525                                      .$QualColName."`");
00526                 }
00527             }
00528         }
00529 
00530         return $this->UpdateValue("HasItemLevelQualifiers", $NewValue);
00531     }
00532 
00533     # get list of qualifiers associated with field
00534     function AssociatedQualifierList()
00535     {
00536         # start with empty list
00537         $List = array();
00538 
00539         # for each associated qualifier
00540         $this->DB->Query("SELECT QualifierId FROM FieldQualifierInts"
00541                      ." WHERE MetadataFieldId = ".$this->DBFields["FieldId"]);
00542         while ($Record = $this->DB->FetchRow())
00543         {
00544             # load qualifier object
00545             $Qual = new Qualifier($Record["QualifierId"]);
00546 
00547             # add qualifier ID and name to list
00548             $List[$Qual->Id()] = $Qual->Name();
00549         }
00550 
00551         # return list to caller
00552         return $List;
00553     }
00554 
00555     # get list of qualifiers not associated with field
00556     function UnassociatedQualifierList()
00557     {
00558         # grab list of associated qualifiers
00559         $AssociatedQualifiers = $this->AssociatedQualifierList();
00560 
00561         # get list of all qualifiers
00562         $QFactory = new QualifierFactory();
00563         $AllQualifiers = $QFactory->QualifierList();
00564 
00565         # return list of unassociated qualifiers
00566         return array_diff($AllQualifiers, $AssociatedQualifiers);
00567     }
00568 
00569     # add qualifier association
00570     function AssociateWithQualifier($QualifierIdOrObject)
00571     {
00572         # if qualifier object passed in
00573         if (is_object($QualifierIdOrObject))
00574         {
00575             # grab qualifier ID from object
00576             $QualifierIdOrObject = $QualifierIdOrObject->Id();
00577         }
00578 
00579         # if not already associated
00580         $RecordCount = $this->DB->Query(
00581             "SELECT COUNT(*) AS RecordCount FROM FieldQualifierInts"
00582             ." WHERE QualifierId = ".$QualifierIdOrObject
00583             ." AND MetadataFieldId = ".$this->Id(), "RecordCount");
00584         if ($RecordCount < 1)
00585         {
00586             # associate field with qualifier
00587             $this->DB->Query("INSERT INTO FieldQualifierInts SET"
00588                              ." QualifierId = ".$QualifierIdOrObject.","
00589                              ." MetadataFieldId = ".$this->Id());
00590         }
00591     }
00592 
00593     # delete qualifier association
00594     function UnassociateWithQualifier($QualifierIdOrObject)
00595     {
00596         # if qualifier object passed in
00597         if (is_object($QualifierIdOrObject))
00598         {
00599             # grab qualifier ID from object
00600             $QualifierIdOrObject = $QualifierIdOrObject->Id();
00601         }
00602 
00603         # delete intersection record from database
00604         $this->DB->Query("DELETE FROM FieldQualifierInts WHERE QualifierId = "
00605                          .$QualifierIdOrObject." AND MetadataFieldId = ".
00606                          $this->Id());
00607     }
00608 
00609     # retrieve item factory object for this field
00610     function GetFactory()
00611     {
00612         switch ($this->Type())
00613         {
00614             case MetadataSchema::MDFTYPE_TREE:
00615                 $Factory = new ClassificationFactory($this->Id());
00616                 break;
00617 
00618             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00619             case MetadataSchema::MDFTYPE_OPTION:
00620                 $Factory = new ControlledNameFactory($this->Id());
00621                 break;
00622 
00623             default:
00624                 $Factory = NULL;
00625                 break;
00626         }
00627 
00628         return $Factory;
00629     }
00630 
00631 
00632     # ---- PRIVATE INTERFACE -------------------------------------------------
00633 
00634     private $DB;
00635     private $DBFields;
00636     private $ErrorStatus;
00637 
00638     # field type DB/PHP enum translations
00639     public static $FieldTypeDBEnums = array(
00640             MetadataSchema::MDFTYPE_TEXT             => "Text",
00641             MetadataSchema::MDFTYPE_PARAGRAPH        => "Paragraph",
00642             MetadataSchema::MDFTYPE_NUMBER           => "Number",
00643             MetadataSchema::MDFTYPE_DATE             => "Date",
00644             MetadataSchema::MDFTYPE_TIMESTAMP        => "TimeStamp",
00645             MetadataSchema::MDFTYPE_FLAG             => "Flag",
00646             MetadataSchema::MDFTYPE_TREE             => "Tree",
00647             MetadataSchema::MDFTYPE_CONTROLLEDNAME   => "ControlledName",
00648             MetadataSchema::MDFTYPE_OPTION           => "Option",
00649             MetadataSchema::MDFTYPE_USER             => "User",
00650             MetadataSchema::MDFTYPE_IMAGE            => "Still Image",
00651             MetadataSchema::MDFTYPE_FILE             => "File",
00652             MetadataSchema::MDFTYPE_URL              => "Url",
00653             MetadataSchema::MDFTYPE_POINT            => "Point"
00654             );
00655     public static $FieldTypeDBAllowedEnums = array(
00656             MetadataSchema::MDFTYPE_TEXT             => "Text",
00657             MetadataSchema::MDFTYPE_PARAGRAPH        => "Paragraph",
00658             MetadataSchema::MDFTYPE_NUMBER           => "Number",
00659             MetadataSchema::MDFTYPE_DATE             => "Date",
00660             MetadataSchema::MDFTYPE_TIMESTAMP        => "TimeStamp",
00661             MetadataSchema::MDFTYPE_FLAG             => "Flag",
00662             MetadataSchema::MDFTYPE_TREE             => "Tree",
00663             MetadataSchema::MDFTYPE_CONTROLLEDNAME   => "ControlledName",
00664             MetadataSchema::MDFTYPE_OPTION           => "Option",
00665             MetadataSchema::MDFTYPE_IMAGE            => "Still Image",
00666             MetadataSchema::MDFTYPE_FILE             => "File",
00667             MetadataSchema::MDFTYPE_URL              => "Url",
00668             MetadataSchema::MDFTYPE_POINT            => "Point"
00669             );
00670     public static $FieldTypePHPEnums = array(
00671             "Text"                   => MetadataSchema::MDFTYPE_TEXT,
00672             "Paragraph"              => MetadataSchema::MDFTYPE_PARAGRAPH,
00673             "Number"                 => MetadataSchema::MDFTYPE_NUMBER,
00674             "Date"                   => MetadataSchema::MDFTYPE_DATE,
00675             "TimeStamp"              => MetadataSchema::MDFTYPE_TIMESTAMP,
00676             "Flag"                   => MetadataSchema::MDFTYPE_FLAG,
00677             "Tree"                   => MetadataSchema::MDFTYPE_TREE,
00678             "ControlledName"         => MetadataSchema::MDFTYPE_CONTROLLEDNAME,
00679             "Option"                 => MetadataSchema::MDFTYPE_OPTION,
00680             "User"                   => MetadataSchema::MDFTYPE_USER,
00681             "Still Image"            => MetadataSchema::MDFTYPE_IMAGE,
00682             "File"                   => MetadataSchema::MDFTYPE_FILE,
00683             "Url"                    => MetadataSchema::MDFTYPE_URL,
00684             "Point"                  => MetadataSchema::MDFTYPE_POINT
00685             );
00686 
00687     public static $UpdateTypes = array(
00688         MetadataField::UPDATEMETHOD_NOAUTOUPDATE   => "Do not update automatically",
00689         MetadataField::UPDATEMETHOD_ONRECORDCREATE => "Update on record creation",
00690         MetadataField::UPDATEMETHOD_BUTTON         => "Provide an update button",
00691         MetadataField::UPDATEMETHOD_ONRECORDEDIT   => "Update when record is edited",
00692         MetadataField::UPDATEMETHOD_ONRECORDCHANGE => "Update when record is changed"
00693         );
00694 
00695 
00696     # object constructor (only for use by MetadataSchema object)
00697     function MetadataField($FieldId, $FieldName = NULL, $FieldType = NULL,
00698                            $Optional = TRUE, $DefaultValue = NULL)
00699     {
00700         # assume everything will be okay
00701         $this->ErrorStatus = MetadataSchema::MDFSTAT_OK;
00702 
00703         # grab our own database handle
00704         $this->DB = new Database();
00705         $DB = $this->DB;
00706 
00707         # if field ID supplied
00708         if ($FieldId != NULL)
00709         {
00710             # look up field in database
00711             $DB->Query("SELECT * FROM MetadataFields WHERE FieldId = ".intval($FieldId));
00712             $Record = $DB->FetchRow();
00713         }
00714 
00715         # if no field ID supplied or if record not found in database
00716         if (($FieldId == NULL) || ($Record == NULL))
00717         {
00718             # error out if valid field type not supplied
00719             if (empty(MetadataField::$FieldTypeDBEnums[$FieldType]))
00720             {
00721                 $this->ErrorStatus = MetadataSchema::MDFSTAT_FIELDDOESNOTEXIST;
00722                 return;
00723             }
00724 
00725             # if field name supplied
00726             $FieldName = trim($FieldName);
00727             if (strlen($FieldName) > 0)
00728             {
00729                 # error out if field name is duplicate
00730                 $DuplicateCount = $DB->Query(
00731                         "SELECT COUNT(*) AS RecordCount FROM MetadataFields "
00732                             ."WHERE FieldName = '".addslashes($FieldName)."'",
00733                         "RecordCount");
00734                 if ($DuplicateCount > 0)
00735                 {
00736                     $this->ErrorStatus = MetadataSchema::MDFSTAT_DUPLICATENAME;
00737                     return;
00738                 }
00739             }
00740 
00741             # grab current user ID
00742             global $G_User;
00743             $UserId = $G_User->Get("UserId");
00744 
00745             # lock DB tables and get next temporary field ID
00746             $Schema = new MetadataSchema();
00747             $DB->Query("LOCK TABLES MetadataFields WRITE");
00748             $FieldId = $Schema->GetNextTempItemId();
00749 
00750             # add field to MDF table in database
00751             $DB->Query("INSERT INTO MetadataFields "
00752                   ."(FieldId, FieldName, FieldType, Optional, DefaultValue, LastModifiedById) VALUES "
00753                   ."(".intval($FieldId).", "
00754                   ."'".addslashes($FieldName)."', "
00755                   ."'".MetadataField::$FieldTypeDBEnums[$FieldType]."', "
00756                   .($Optional ? 1 : 0).", "
00757                   ."'".addslashes($DefaultValue)."',"
00758                   ."'".$UserId."')");
00759 
00760             # release DB tables
00761             $DB->Query("UNLOCK TABLES");
00762 
00763             # re-read record from database
00764             $DB->Query("SELECT * FROM MetadataFields WHERE FieldId = "
00765                     .intval($FieldId));
00766             $this->DBFields = $DB->FetchRow();
00767             $this->DBFields["DBFieldName"] =
00768                     $this->NormalizeFieldNameForDB($this->DBFields["FieldName"]);
00769 
00770             # set field order values for new field
00771             $FieldCount = $DB->Query("SELECT COUNT(*) AS FieldCount FROM MetadataFields", "FieldCount");
00772             $this->OrderPosition(MetadataSchema::MDFORDER_DISPLAY,
00773                                  ($FieldCount + 1));
00774             $this->OrderPosition(MetadataSchema::MDFORDER_EDITING,
00775                                  ($FieldCount + 1));
00776         }
00777         else
00778         {
00779             # save values locally
00780             $this->DBFields = $Record;
00781             $this->DBFields["DBFieldName"] =
00782                     $this->NormalizeFieldNameForDB($Record["FieldName"]);
00783         }
00784     }
00785 
00786     # remove field from database (only for use by MetadataSchema object)
00787     function Drop()
00788     {
00789         # clear other database entries as appropriate for field type
00790         $DB = $this->DB;
00791         $DBFieldName = $this->DBFields["DBFieldName"];
00792         switch (MetadataField::$FieldTypePHPEnums[$this->DBFields["FieldType"]])
00793         {
00794             case MetadataSchema::MDFTYPE_TEXT:
00795             case MetadataSchema::MDFTYPE_PARAGRAPH:
00796             case MetadataSchema::MDFTYPE_NUMBER:
00797             case MetadataSchema::MDFTYPE_USER:
00798             case MetadataSchema::MDFTYPE_IMAGE:
00799             case MetadataSchema::MDFTYPE_TIMESTAMP:
00800             case MetadataSchema::MDFTYPE_URL:
00801                 # remove field from resources table
00802                 if ($DB->FieldExists("Resources", $DBFieldName))
00803                 {
00804                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."`");
00805                 }
00806                 break;
00807 
00808             case MetadataSchema::MDFTYPE_POINT:
00809                 if ($DB->FieldExists("Resources", $DBFieldName."X"))
00810                 {
00811                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."X`");
00812                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."Y`");
00813                 }
00814                 break;
00815 
00816             case MetadataSchema::MDFTYPE_FLAG:
00817                 # remove field from resources table
00818                 if ($DB->FieldExists("Resources", $DBFieldName))
00819                 {
00820                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."`");
00821                 }
00822                 break;
00823 
00824             case MetadataSchema::MDFTYPE_DATE:
00825                 # remove fields from resources table
00826                 if ($DB->FieldExists("Resources", $DBFieldName."Begin"))
00827                 {
00828                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."Begin`");
00829                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."End`");
00830                     $DB->Query("ALTER TABLE Resources DROP COLUMN `".$DBFieldName."Precision`");
00831                 }
00832                 break;
00833 
00834             case MetadataSchema::MDFTYPE_TREE:
00835                 $DB->Query("SELECT ClassificationId FROM Classifications "
00836                            ."WHERE FieldId = ".$this->Id());
00837                 $TempDB = new SPTDatabase();
00838                 while ($ClassificationId = $DB->FetchField("ClassificationId"))
00839                 {
00840                     # remove any resource / name intersections
00841                     $TempDB->Query("DELETE FROM ResourceClassInts WHERE "
00842                                    ."ClassificationId = ".$ClassificationId);
00843 
00844                     # remove controlled name
00845                     $TempDB->Query("DELETE FROM Classifications WHERE "
00846                                    ."ClassificationId = ".$ClassificationId);
00847                 }
00848                 break;
00849 
00850             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
00851             case MetadataSchema::MDFTYPE_OPTION:
00852                 $DB->Query("SELECT ControlledNameId FROM ControlledNames "
00853                            ."WHERE FieldId = ".$this->Id());
00854                 $TempDB = new SPTDatabase();
00855                 while ($ControlledNameId = $DB->FetchField("ControlledNameId"))
00856                 {
00857                     # remove any resource / name intersections
00858                     $TempDB->Query("DELETE FROM ResourceNameInts WHERE "
00859                                    ."ControlledNameId = ".$ControlledNameId);
00860 
00861                     # remove any variant names
00862                     $TempDB->Query("DELETE FROM VariantNames WHERE "
00863                                    ."ControlledNameId = ".$ControlledNameId);
00864 
00865                     # remove controlled name
00866                     $TempDB->Query("DELETE FROM ControlledNames WHERE "
00867                                    ."ControlledNameId = ".$ControlledNameId);
00868                 }
00869                 break;
00870 
00871             case MetadataSchema::MDFTYPE_FILE:
00872                 # for each file associated with this field
00873                 $DB->Query("SELECT FileId FROM Files WHERE FieldId = '".$this->Id()."'");
00874                 while ($FileId = $DB->FetchRow())
00875                 {
00876                     # delete file
00877                     $File = new File(intval($FileId));
00878                     $File->Delete();
00879                 }
00880                 break;
00881         }
00882 
00883         # remove field from database
00884         $DB->Query("DELETE FROM MetadataFields "
00885                    ."WHERE FieldId = '".$this->DBFields["FieldId"]."'");
00886 
00887         # remove any qualifier associations
00888         $DB->Query("DELETE FROM FieldQualifierInts WHERE MetadataFieldId = '"
00889                    .$this->DBFields["FieldId"]."'");
00890     }
00891 
00892     # modify any database fields
00893     function ModifyField($NewName = NULL, $NewType = NULL)
00894     {
00895         # grab old DB field name
00896         $OldDBFieldName = $this->DBFields["DBFieldName"];
00897         $OldFieldType = NULL;
00898 
00899         # if new field name supplied
00900         if ($NewName != NULL)
00901         {
00902             # cache the old name for options and controllednames below
00903             $OldName = $this->DBFields["FieldName"];
00904 
00905             # store new name
00906             $this->UpdateValue("FieldName", $NewName);
00907 
00908             # determine new DB field name
00909             $NewDBFieldName = $this->NormalizeFieldNameForDB($NewName);
00910 
00911             # store new database field name
00912             $this->DBFields["DBFieldName"] = $NewDBFieldName;
00913         }
00914         else
00915         {
00916             # set new field name equal to old field name
00917             $NewDBFieldName = $OldDBFieldName;
00918         }
00919 
00920         # if new type supplied
00921         if ($NewType != NULL)
00922         {
00923             # grab old field type
00924             $OldFieldType = MetadataField::$FieldTypePHPEnums[$this->DBFields["FieldType"]];
00925 
00926             # store new field type
00927             $this->UpdateValue("FieldType", MetadataField::$FieldTypeDBEnums[$NewType]);
00928         }
00929 
00930         # if this is not a temporary field
00931         if ($this->Id() >= 0)
00932         {
00933             # modify field in DB as appropriate for field type
00934             $DB = $this->DB;
00935             $FieldType = MetadataField::$FieldTypePHPEnums[$this->DBFields["FieldType"]];
00936             switch ($FieldType)
00937             {
00938                 case MetadataSchema::MDFTYPE_TEXT:
00939                 case MetadataSchema::MDFTYPE_PARAGRAPH:
00940                 case MetadataSchema::MDFTYPE_URL:
00941                     # alter field declaration in Resources table
00942                     $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
00943                                .$OldDBFieldName."` `"
00944                                .$NewDBFieldName."` TEXT "
00945                                .($this->DBFields["Optional"] ? "" : "NOT NULL"));
00946                     break;
00947 
00948                 case MetadataSchema::MDFTYPE_NUMBER:
00949                 case MetadataSchema::MDFTYPE_USER:
00950                     # alter field declaration in Resources table
00951                     $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
00952                                .$OldDBFieldName."` `"
00953                                .$NewDBFieldName."` INT "
00954                                .($this->DBFields["Optional"] ? "" : "NOT NULL"));
00955                     break;
00956 
00957                 case MetadataSchema::MDFTYPE_POINT:
00958                     $Precision = $this->UpdateValue("PointPrecision",
00959                                                     DB_NOVALUE);
00960                     $Digits    = $this->UpdateValue("PointDecimalDigits",
00961                                                     DB_NOVALUE);
00962                     $DB->Query("ALTER TABLE Resources CHANGE COLUMN "
00963                                ."`".$OldDBFieldName."X` "
00964                                ."`".$NewDBFieldName."X`".
00965                                " DECIMAL(".$Precision.",".$Digits.")");
00966                     $DB->Query("ALTER TABLE Resources CHANGE COLUMN "
00967                                ."`".$OldDBFieldName."Y` "
00968                                ."`".$NewDBFieldName."Y`".
00969                                " DECIMAL(".$Precision.",".$Digits.")");
00970                     break;
00971 
00972                 case MetadataSchema::MDFTYPE_FILE:
00973                     # if DB field name has changed
00974                     if ($NewDBFieldName != $OldDBFieldName)
00975                     {
00976                         # alter field declaration in Resources table
00977                         $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
00978                                    .$OldDBFieldName."` `"
00979                                    .$NewDBFieldName."` TEXT");
00980                     }
00981                     break;
00982 
00983                 case MetadataSchema::MDFTYPE_IMAGE:
00984                     # if DB field name has changed
00985                     if ($NewDBFieldName != $OldDBFieldName)
00986                     {
00987                         # alter field declaration in Resources table
00988                         $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
00989                                    .$OldDBFieldName."` `"
00990                                    .$NewDBFieldName."` INT");
00991                     }
00992                     break;
00993 
00994                 case MetadataSchema::MDFTYPE_FLAG:
00995                     # alter field declaration in Resources table
00996                     $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
00997                                .$OldDBFieldName."` `"
00998                                .$NewDBFieldName."` INT"
00999                                ." DEFAULT ".intval($this->DefaultValue()));
01000 
01001                     # set any unset values to default
01002                     $DB->Query("UPDATE Resources SET `".$NewDBFieldName
01003                             ."` = ".intval($this->DefaultValue())
01004                             ." WHERE `".$NewDBFieldName."` IS NULL");
01005                     break;
01006 
01007                 case MetadataSchema::MDFTYPE_DATE:
01008                     # if new type supplied and new type is different from old
01009                     if (($NewType != NULL) && ($NewType != $OldFieldType))
01010                     {
01011                         # if old type was time stamp
01012                         if ($OldFieldType == MetadataSchema::MDFTYPE_TIMESTAMP)
01013                         {
01014                             # change time stamp field in resources table to begin date
01015                             $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01016                                        .$OldDBFieldName."` `"
01017                                        .$NewDBFieldName."Begin` DATE "
01018                                        .($this->DBFields["Optional"] ? "" : "NOT NULL"));
01019 
01020                             # add end date and precision fields
01021                             $DB->Query("ALTER TABLE Resources ADD COLUMN `".$NewDBFieldName."End"
01022                                        ."` DATE");
01023                             $DB->Query("ALTER TABLE Resources ADD COLUMN `".$NewDBFieldName."Precision`"
01024                                        ." INT ".($Optional ? "" : "NOT NULL"));
01025 
01026                             # set precision to reflect time stamp content
01027                             $DB->Query("UPDATE Resources SET `".$NewDBFieldName."Precision` = "
01028                                        .(DATEPRE_BEGINYEAR|DATEPRE_BEGINMONTH|DATEPRE_BEGINDAY));
01029                         }
01030                         else
01031                         {
01032                             exit("<br>ERROR:  Attempt to convert metadata field to date from type other than timestamp<br>\n");
01033                         }
01034                     }
01035                     else
01036                     {
01037                         # change name of fields
01038                         $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01039                                    .$OldDBFieldName."Begin` `"
01040                                    .$NewDBFieldName."Begin` DATE "
01041                                    .($this->DBFields["Optional"] ? "" : "NOT NULL"));
01042                         $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01043                                    .$OldDBFieldName."End` `"
01044                                    .$NewDBFieldName."End` DATE "
01045                                    .($this->DBFields["Optional"] ? "" : "NOT NULL"));
01046                         $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01047                                    .$OldDBFieldName."Precision` `"
01048                                    .$NewDBFieldName."Precision` INT "
01049                                    .($this->DBFields["Optional"] ? "" : "NOT NULL"));
01050                     }
01051                     break;
01052 
01053                 case MetadataSchema::MDFTYPE_TIMESTAMP:
01054                     # if new type supplied and new type is different from old
01055                     if (($NewType != NULL) && ($NewType != $OldFieldType))
01056                     {
01057                         # if old type was date
01058                         if ($OldFieldType == MetadataSchema::MDFTYPE_DATE)
01059                         {
01060                             # change begin date field in resource table to time stamp
01061                             $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01062                                        .$OldDBFieldName."Begin` `"
01063                                        .$NewDBFieldName."` DATETIME "
01064                                        .($this->DBFields["Optional"] ? "" : "NOT NULL"));
01065 
01066                             # drop end date and precision fields
01067                             $DB->Query("ALTER TABLE Resources DROP COLUMN `"
01068                                        .$OldDBFieldName."End`");
01069                             $DB->Query("ALTER TABLE Resources DROP COLUMN `"
01070                                        .$OldDBFieldName."Precision`");
01071                         }
01072                         else
01073                         {
01074                             exit("<br>ERROR:  Attempt to convert metadata field to time stamp from type other than date<br>\n");
01075                         }
01076                     }
01077                     else
01078                     {
01079                         # change name of field
01080                         $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01081                                    .$OldDBFieldName."` `"
01082                                    .$NewDBFieldName."` DATETIME "
01083                                    .($this->DBFields["Optional"] ? "" : "NOT NULL"));
01084                     }
01085                     break;
01086 
01087                 case MetadataSchema::MDFTYPE_TREE:
01088                 case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
01089                 case MetadataSchema::MDFTYPE_OPTION:
01090                     break;
01091             }
01092 
01093             # if qualifier DB field exists
01094             if ($DB->FieldExists("Resources", $OldDBFieldName."Qualifier"))
01095             {
01096                 # rename qualifier DB field
01097                 $DB->Query("ALTER TABLE Resources CHANGE COLUMN `"
01098                            .$OldDBFieldName."Qualifier` `"
01099                            .$NewDBFieldName."Qualifier` INT ");
01100             }
01101         }
01102     }
01103 
01104     # convenience function to supply parameters to Database->UpdateValue()
01105     function UpdateValue($FieldName, $NewValue)
01106     {
01107         return $this->DB->UpdateValue("MetadataFields", $FieldName, $NewValue,
01108                                "FieldId = ".intval($this->DBFields["FieldId"]),
01109                                $this->DBFields);
01110     }
01111 
01112     # normalize field name for use as database field name
01113     function NormalizeFieldNameForDB($Name)
01114     {
01115         return preg_replace("/[^a-z0-9]/i", "", $Name);
01116     }
01117 
01118     # add any needed database fields and/or entries
01119     function AddDatabaseFields()
01120     {
01121         # grab values for common use
01122         $DB = $this->DB;
01123         $FieldName = $this->Name();
01124         $DBFieldName = $this->DBFieldName();
01125         $Optional = $this->Optional();
01126         $DefaultValue = $this->DefaultValue();
01127 
01128         # set up field(s) based on field type
01129         switch ($this->Type())
01130         {
01131             case MetadataSchema::MDFTYPE_TEXT:
01132             case MetadataSchema::MDFTYPE_PARAGRAPH:
01133             case MetadataSchema::MDFTYPE_URL:
01134                 # add field to resources table (if not already present)
01135                 if (!$DB->FieldExists("Resources", $DBFieldName))
01136                 {
01137                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName
01138                                ."` TEXT ".($Optional ? "" : "NOT NULL"));
01139                 }
01140 
01141                 # if default value supplied
01142                 if ($DefaultValue != NULL)
01143                 {
01144                     # set all existing records to default value
01145                     $DB->Query("UPDATE Resources SET `"
01146                                .$DBFieldName."` = '".addslashes($DefaultValue)."'");
01147                 }
01148                 break;
01149 
01150             case MetadataSchema::MDFTYPE_NUMBER:
01151                 # add field to resources table (if not already present)
01152                 if (!$DB->FieldExists("Resources", $DBFieldName))
01153                 {
01154                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName
01155                                ."` INT ".($Optional ? "" : "NOT NULL"));
01156                 }
01157 
01158                 # if default value supplied
01159                 if ($DefaultValue != NULL)
01160                 {
01161                     # set all existing records to default value
01162                     $DB->Query("UPDATE Resources SET `"
01163                                .$DBFieldName."` = '".addslashes($DefaultValue)."'");
01164                 }
01165                 break;
01166 
01167             case MetadataSchema::MDFTYPE_POINT:
01168                 if (!$DB->FieldExists("Resources", $DBFieldName."X"))
01169                 {
01170                     $Precision = $this->UpdateValue("PointPrecision",
01171                                                     DB_NOVALUE);
01172                     $Digits    = $this->UpdateValue("PointDecimalDigits",
01173                                                     DB_NOVALUE);
01174 
01175                     $DB->Query("ALTER TABLE Resources ADD COLUMN `"
01176                                .$DBFieldName."X`".
01177                                " DECIMAL(".$Precision.",".$Digits.")");
01178                     $DB->Query("ALTER TABLE Resources ADD COLUMN `"
01179                                .$DBFieldName."Y`".
01180                                " DECIMAL(".$Precision.",".$Digits.")");
01181                 }
01182 
01183                 break;
01184             case MetadataSchema::MDFTYPE_FLAG:
01185                 # if field is not already present in database
01186                 if (!$DB->FieldExists("Resources", $DBFieldName))
01187                 {
01188                     # add field to resources table
01189                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName
01190                                ."` INT DEFAULT ".intval($DefaultValue));
01191 
01192                     # set all existing records to default value
01193                     $DB->Query("UPDATE Resources SET `"
01194                                .$DBFieldName."` = ".intval($DefaultValue));
01195                 }
01196                 break;
01197 
01198             case MetadataSchema::MDFTYPE_USER:
01199                 # add field to resources table (if not already present)
01200                 if (!$DB->FieldExists("Resources", $DBFieldName))
01201                 {
01202                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName
01203                                ."` INT ".($Optional ? "" : "NOT NULL"));
01204                 }
01205                 break;
01206 
01207             case MetadataSchema::MDFTYPE_FILE:
01208                 # add fields to resources table (if not already present)
01209                 if (!$DB->FieldExists("Resources", $DBFieldName))
01210                 {
01211                     $DB->Query("ALTER TABLE Resources ADD COLUMN `"
01212                                .$DBFieldName."` TEXT");
01213                 }
01214                 break;
01215 
01216             case MetadataSchema::MDFTYPE_IMAGE:
01217                 # add fields to resources table (if not already present)
01218                 if (!$DB->FieldExists("Resources", $DBFieldName))
01219                 {
01220                     $DB->Query("ALTER TABLE Resources ADD COLUMN `"
01221                                .$DBFieldName."` INT");
01222                 }
01223                 break;
01224 
01225             case MetadataSchema::MDFTYPE_DATE:
01226                 # add fields to resources table (if not already present)
01227                 if (!$DB->FieldExists("Resources", $DBFieldName."Begin"))
01228                 {
01229                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName."Begin`"
01230                                ." DATE ".($Optional ? "" : "NOT NULL"));
01231                 }
01232                 if (!$DB->FieldExists("Resources", $DBFieldName."End"))
01233                 {
01234                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName."End`"
01235                                ." DATE");
01236                 }
01237                 if (!$DB->FieldExists("Resources", $DBFieldName."Precision"))
01238                 {
01239                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName."Precision`"
01240                                ." INT ".($Optional ? "" : "NOT NULL"));
01241                 }
01242                 break;
01243 
01244             case MetadataSchema::MDFTYPE_TIMESTAMP:
01245                 # add fields to resources table (if not already present)
01246                 if (!$DB->FieldExists("Resources", $DBFieldName))
01247                 {
01248                     $DB->Query("ALTER TABLE Resources ADD COLUMN `".$DBFieldName
01249                                ."` DATETIME ".($Optional ? "" : "NOT NULL"));
01250                 }
01251                 break;
01252 
01253             case MetadataSchema::MDFTYPE_TREE:
01254             case MetadataSchema::MDFTYPE_CONTROLLEDNAME:
01255             case MetadataSchema::MDFTYPE_OPTION:
01256                 break;
01257 
01258             default:
01259                 exit("<br>ERROR:  Attempt to add database fields for illegal metadata field type<br>\n");
01260                 break;
01261         }
01262     }
01263 
01264     # get/set field order positions
01265     function OrderPosition($OrderType, $NewValue = DB_NOVALUE)
01266     {
01267         switch ($OrderType)
01268         {
01269             case MetadataSchema::MDFORDER_DISPLAY:
01270                 return $this->UpdateValue("DisplayOrderPosition", $NewValue);
01271                 break;
01272 
01273             case MetadataSchema::MDFORDER_EDITING:
01274                 return $this->UpdateValue("EditingOrderPosition", $NewValue);
01275                 break;
01276 
01277             default:
01278                 exit("invalid order type passed to MetadataField::OrderPosition");
01279                 break;
01280         }
01281     }
01282 }
01283 
01284 
01285 ?>