5 # Part of the Collection Workflow Information System (CWIS)
6 # Copyright 2012-2013 Edward Almasy and Internet Scout Research Group
7 # http://scout.wisc.edu/cwis/
19 # ---- PUBLIC INTERFACE --------------------------------------------------
30 # create our own DB handle
34 $this->
Id = intval($FolderId);
36 # attempt to load in folder info
37 $this->DB->Query(
"SELECT * FROM Folders WHERE FolderId = ".$this->
Id);
38 $Record = $this->DB->FetchRow();
40 # if folder was not found
41 if ($Record === FALSE)
43 # bail out with exception
44 throw new Exception(
"Unknown Folder ID (".$FolderId.
").");
48 $this->
OwnerId = $Record[
"OwnerId"];
49 $this->FolderName = $Record[
"FolderName"];
51 $this->FolderNote = $Record[
"FolderNote"];
52 $this->
IsShared = $Record[
"IsShared"];
53 $this->ContentType = $Record[
"ContentType"];
54 $this->UpdateValueCache = $Record;
56 # load list of resources in folder from database
57 $this->DB->Query(
"SELECT ItemId, ItemTypeId, ItemNote FROM FolderItemInts"
58 .
" WHERE FolderId = ".$this->
Id);
60 # create internal cache for item notes
61 $this->ItemNoteCache = array();
62 while ($Record = $this->DB->FetchRow())
64 $Index = self::GetCacheIndex($Record[
"ItemId"], $Record[
"ItemTypeId"]);
65 $this->ItemNoteCache[$Index] = $Record[
"ItemNote"];
69 if ($this->ContentType == self::MIXEDCONTENT)
72 "FolderItemInts",
"ItemId",
"FolderId = ".$this->
Id,
"ItemTypeId");
77 "FolderItemInts",
"ItemId",
"FolderId = ".$this->
Id);
86 # take folder out of global folder order
88 $Factory->RemoveItemFromOrder($this->
Id);
90 # remove resource listings from DB
91 $this->DB->Query(
"DELETE FROM FolderItemInts WHERE FolderId = ".$this->
Id);
93 # remove folder listing from DB
94 $this->DB->Query(
"DELETE FROM Folders WHERE FolderId = ".$this->
Id);
98 # ------------------------------------------------------------------------
121 return $this->UpdateValue(
"FolderName", $NewValue);
133 $Name = $this->UpdateValue(
"NormalizedName", $NewValue);
134 # attempt to generate and set new normalized name if none found
137 $Name = $this->UpdateValue(
"NormalizedName",
138 self::NormalizeFolderName($this->
Name()));
150 return preg_replace(
"/[^a-z0-9]/",
"", strtolower($Name));
161 return $this->UpdateValue(
"IsShared", $NewValue);
171 if ($NewValue !==
DB_NOVALUE) { unset($this->Owner); }
172 return intval($this->UpdateValue(
"OwnerId", $NewValue));
182 return $this->UpdateValue(
"FolderNote", $NewValue);
186 # ------------------------------------------------------------------------
202 $TargetItemType = NULL, $NewItemType = NULL)
204 $this->AddItem($NewItemOrItemId, $NewItemType);
205 $this->OrderList->InsertBefore($TargetItemOrItemId, $NewItemOrItemId,
206 self::GetItemTypeId($TargetItemType),
207 self::GetItemTypeId($NewItemType));
222 $TargetItemType = NULL, $NewItemType = NULL)
224 $this->AddItem($NewItemOrItemId, $NewItemType);
225 $this->OrderList->InsertAfter($TargetItemOrItemId, $NewItemOrItemId,
226 self::GetItemTypeId($TargetItemType),
227 self::GetItemTypeId($NewItemType));
239 $this->AddItem($ItemOrItemId, $ItemType);
240 $this->OrderList->Prepend($ItemOrItemId, self::GetItemTypeId($ItemType));
252 $this->AddItem($ItemOrItemId, $ItemType);
253 $this->OrderList->Append($ItemOrItemId, self::GetItemTypeId($ItemType));
265 # retrieve item ordered list of type IDs
266 $ItemIds = $this->OrderList->GetIds();
268 # if this is a mixed-item-type folder
269 if ($this->ContentType == self::MIXEDCONTENT)
271 # convert item type IDs to corresponding type names
272 $NewItemIds = array();
273 foreach ($ItemIds as $ItemInfo)
275 $NewItemIds[] = array(
276 "ID" => $ItemInfo[
"ID"],
277 "Type" => self::GetItemTypeName($ItemInfo[
"Type"]),
280 $ItemIds = $NewItemIds;
283 # return list of item type IDs (and possibly types) to caller
295 # if resource is in folder
298 # remove item from item order
299 $ItemTypeId = self::GetItemTypeId($ItemType);
300 $this->OrderList->Remove($ItemId, $ItemTypeId);
302 # remove resource from folder locally
303 unset($this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)]);
305 # remove resource from folder in DB
306 $this->DB->Query(
"DELETE FROM FolderItemInts"
307 .
" WHERE FolderId = ".intval($this->
Id)
308 .
" AND ItemId = ".intval($ItemId)
309 .
" AND ItemTypeId = ".intval($ItemTypeId));
322 $ItemTypeId = self::GetItemTypeId($ItemType);
323 $Index = self::GetCacheIndex($ItemId, $ItemTypeId);
324 $DummyCache = array(
"ItemNote" => $this->ItemNoteCache[$Index]);
326 $Value = $this->DB->UpdateValue(
"FolderItemInts",
"ItemNote", $NewValue,
327 "FolderId = ".intval($this->
Id)
328 .
" AND ItemId = ".intval($ItemId)
329 .
" AND ItemTypeId = ".intval($ItemTypeId),
332 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = $Value;
345 $ItemTypeId = self::GetItemTypeId($ItemType);
346 return array_key_exists(self::GetCacheIndex($ItemId, $ItemTypeId),
347 $this->ItemNoteCache) ? TRUE : FALSE;
352 # ---- PRIVATE INTERFACE -------------------------------------------------
357 # folder attributes - these much match field names in Folders DB table
360 private $NormalizedName;
363 private $ContentType;
365 private $ItemNoteCache;
367 private $UpdateValueCache;
369 # item type IDs (indexed by normalized type name)
370 static private $ItemTypeIds;
371 # item type names (indexed by type ID)
372 static private $ItemTypeNames;
374 # content type that indicates folder contains mixed content types
384 static function GetItemTypeId($TypeName)
386 # return "no type" ID if null passed in
387 if ($TypeName === NULL) {
return -1; }
389 # make sure item type map is loaded
390 self::LoadItemTypeMap();
392 # normalize item type name
393 $NormalizedTypeName = strtoupper(
394 preg_replace(
"/[^a-zA-Z0-9]/",
"", $TypeName));
396 # if name not already mapped
397 if (!array_key_exists($NormalizedTypeName, self::$ItemTypeIds))
399 # add name to database
400 if (!isset($DB)) { $DB =
new Database(); }
401 $DB->Query(
"INSERT INTO FolderContentTypes SET"
402 .
" TypeName = '".addslashes($TypeName).
"',"
403 .
" NormalizedTypeName = '".addslashes($NormalizedTypeName).
"'");
405 # add name to cached mappings
406 $NewTypeId = $DB->LastInsertId(
"FolderContentTypes");
407 self::$ItemTypeIds[$NormalizedTypeName] = $NewTypeId;
408 self::$ItemTypeNames[$NewTypeId] = $TypeName;
411 # return item type ID to caller
412 return self::$ItemTypeIds[$NormalizedTypeName];
421 private static function GetItemTypeName($TypeId)
423 # make sure item type map is loaded
424 self::LoadItemTypeMap();
426 # if ID not present in mappings
427 if (!array_key_exists($TypeId, self::$ItemTypeNames))
434 # return item type name to caller
435 return self::$ItemTypeNames[$TypeId];
443 private static function LoadItemTypeMap()
445 # if name-to-number item type map not already loaded
446 if (!isset(self::$ItemTypeIds))
448 # load item type map from database
450 $DB->Query(
"SELECT * FROM FolderContentTypes");
451 self::$ItemTypeIds = array();
452 self::$ItemTypeNames = array();
453 while ($Row = $DB->FetchRow())
455 self::$ItemTypeIds[$Row[
"NormalizedTypeName"]] = $Row[
"TypeId"];
456 self::$ItemTypeNames[$Row[
"TypeId"]] = $Row[
"TypeName"];
466 private function AddItem($ItemOrItemId, $ItemType)
468 # convert item to ID if necessary
469 $ItemId = is_object($ItemOrItemId)
470 ? $ItemOrItemId->Id() : $ItemOrItemId;
472 # convert item type to item type ID
473 $ItemTypeId = self::GetItemTypeId($ItemType);
475 # convert null item type to "no type" value used in database
476 if ($ItemTypeId === NULL) { $ItemTypeId = -1; }
478 # if resource is not already in folder
481 # add resource to folder locally
482 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = NULL;
484 # add resource to folder in DB
485 $this->DB->Query(
"INSERT INTO FolderItemInts SET"
486 .
" FolderId = ".intval($this->
Id)
487 .
", ItemId = ".intval($ItemId)
488 .
", ItemTypeId = ".intval($ItemTypeId));
498 private static function GetCacheIndex($ItemId, $ItemTypeId)
500 $ItemTypeId = ($ItemTypeId === NULL) ? -1 : $ItemTypeId;
501 return intval($ItemTypeId).
":".intval($ItemId);
511 private function UpdateValue($FieldName, $NewValue)
513 $this->$FieldName = $this->DB->UpdateValue(
"Folders", $FieldName, $NewValue,
514 "FolderId = ".$this->
Id, $this->UpdateValueCache);
515 return $this->$FieldName;
NormalizedName($NewValue=DB_NOVALUE)
Get/set normalized version of folder name.
AppendItem($ItemOrItemId, $ItemType=NULL)
Add item to folder as the last item.
NoteForItem($ItemId, $NewValue=DB_NOVALUE, $ItemType=NULL)
Get/set note text for specific item within folder.
SQL database abstraction object with smart query caching.
IsShared($NewValue=DB_NOVALUE)
Get/set whether folder is publically-viewable.
GetItemIds()
Retrieve array of IDs of items in folder, in the order that they appear in the folder.
Factory object for Folder class, used to retrieve and manage Folders and groups of Folders...
Folder object used to create and manage groups of items.
RemoveItem($ItemId, $ItemType=NULL)
Remove item from folder, if present.
static NormalizeFolderName($Name)
Convert folder name to normalized form (lower-case alphanumeric only).
InsertItemAfter($TargetItemOrItemId, $NewItemOrItemId, $TargetItemType=NULL, $NewItemType=NULL)
Insert item into folder after specified item.
Note($NewValue=DB_NOVALUE)
Get/set note text for folder.
ContainsItem($ItemId, $ItemType=NULL)
Check whether specified item is contained in folder.
Folder($FolderId)
Object constructor – load an existing folder.
InsertItemBefore($TargetItemOrItemId, $NewItemOrItemId, $TargetItemType=NULL, $NewItemType=NULL)
Insert item into folder before specified item.
Persistent doubly-linked-list data structure, with its data stored in a specified database table...
OwnerId($NewValue=DB_NOVALUE)
Get/set user ID of folder owner.
PrependItem($ItemOrItemId, $ItemType=NULL)
Add item to folder as the first item.
Name($NewValue=DB_NOVALUE)
Get/set folder name.