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/ 20 # ---- PUBLIC INTERFACE -------------------------------------------------- 31 # create our own DB handle 35 $this->
Id = intval($FolderId);
37 # attempt to load in folder info 38 $this->DB->Query(
"SELECT * FROM Folders WHERE FolderId = ".$this->
Id);
39 $Record = $this->DB->FetchRow();
41 # if folder was not found 42 if ($Record === FALSE)
44 # bail out with exception 45 throw new Exception(
"Unknown Folder ID (".$FolderId.
").");
49 $this->
OwnerId = $Record[
"OwnerId"];
50 $this->FolderName = $Record[
"FolderName"];
52 $this->FolderNote = $Record[
"FolderNote"];
53 $this->
IsShared = $Record[
"IsShared"];
54 $this->ContentType = $Record[
"ContentType"];
55 $this->UpdateValueCache = $Record;
57 # load list of resources in folder from database 58 $this->DB->Query(
"SELECT ItemId, ItemTypeId, ItemNote FROM FolderItemInts" 59 .
" WHERE FolderId = ".$this->
Id);
61 # create internal cache for item notes 62 $this->ItemNoteCache = array();
63 while ($Record = $this->DB->FetchRow())
65 $Index = self::GetCacheIndex($Record[
"ItemId"], $Record[
"ItemTypeId"]);
66 $this->ItemNoteCache[$Index] = $Record[
"ItemNote"];
70 if ($this->ContentType == self::MIXEDCONTENT)
73 "FolderItemInts",
"ItemId",
"FolderId = ".$this->
Id,
"ItemTypeId");
78 "FolderItemInts",
"ItemId",
"FolderId = ".$this->
Id);
81 # be sure that a NormalizedName is set 90 # take folder out of global folder order 92 $Factory->RemoveItemFromOrder($this->
Id);
94 # remove resource listings from DB 95 $this->DB->Query(
"DELETE FROM FolderItemInts WHERE FolderId = ".$this->
Id);
97 # remove folder listing from DB 98 $this->DB->Query(
"DELETE FROM Folders WHERE FolderId = ".$this->
Id);
102 # ------------------------------------------------------------------------ 126 return $this->UpdateValue(
"FolderName", $NewValue);
138 $Name = $this->UpdateValue(
"NormalizedName", $NewValue);
139 # attempt to generate and set new normalized name if none found 142 $Name = $this->UpdateValue(
"NormalizedName",
143 self::NormalizeFolderName($this->
Name()));
155 return preg_replace(
"/[^a-z0-9]/",
"", strtolower($Name));
166 return $this->UpdateValue(
"IsShared", $NewValue);
176 if ($NewValue !==
DB_NOVALUE) { unset($this->Owner); }
177 return intval($this->UpdateValue(
"OwnerId", $NewValue));
187 return $this->UpdateValue(
"FolderNote", $NewValue);
191 # ------------------------------------------------------------------------ 207 $TargetItemType = NULL, $NewItemType = NULL)
209 $this->AddItem($NewItemOrItemId, $NewItemType);
210 $this->OrderList->InsertBefore($TargetItemOrItemId, $NewItemOrItemId,
211 self::GetItemTypeId($TargetItemType),
212 self::GetItemTypeId($NewItemType));
227 $TargetItemType = NULL, $NewItemType = NULL)
229 $this->AddItem($NewItemOrItemId, $NewItemType);
230 $this->OrderList->InsertAfter($TargetItemOrItemId, $NewItemOrItemId,
231 self::GetItemTypeId($TargetItemType),
232 self::GetItemTypeId($NewItemType));
244 $this->AddItem($ItemOrItemId, $ItemType);
245 $this->OrderList->Prepend($ItemOrItemId, self::GetItemTypeId($ItemType));
257 $this->AddItem($ItemOrItemId, $ItemType);
258 $this->OrderList->Append($ItemOrItemId, self::GetItemTypeId($ItemType));
269 # convert ItemTypes to an array if it wasn't one 270 if (!is_array($ItemTypes))
272 $NewItemTypes = array();
273 foreach ($ItemsOrItemIds as $Id)
275 $NewItemTypes[] = $ItemTypes;
277 $ItemTypes = $NewItemTypes;
282 foreach ($ItemsOrItemIds as $ItemOrId)
284 $ItemIds[] = is_object($ItemOrId) ? $ItemOrId->Id() : $ItemOrId;
287 # add all the itmes to our folder 288 foreach ($ItemIds as $Index => $ItemId)
290 $this->AddItem($ItemId, $ItemTypes[$Index]);
293 # and add them to our ordering list 294 if ($this->ContentType == self::MIXEDCONTENT)
296 $ItemTypeIds = array();
297 foreach ($ItemTypes as $ItemType)
299 $ItemTypeIds[] = self::GetItemTypeId($ItemType);
302 $this->OrderList->Append($ItemIds, $ItemTypeIds);
306 $this->OrderList->Append($ItemIds);
324 # retrieve item ordered list of type IDs 325 $ItemIds = $this->OrderList->GetIds();
327 # if this is a mixed-item-type folder 328 if ($this->ContentType == self::MIXEDCONTENT)
330 # convert item type IDs to corresponding type names 331 $NewItemIds = array();
332 foreach ($ItemIds as $ItemInfo)
334 $NewItemIds[] = array(
335 "ID" => $ItemInfo[
"ID"],
336 "Type" => self::GetItemTypeName($ItemInfo[
"Type"]),
339 $ItemIds = $NewItemIds;
342 # prune results to subset if requested 343 if ($Offset !== NULL)
345 if ($Length !== NULL)
347 $ItemIds = array_slice($ItemIds, $Offset, $Length);
351 $ItemIds = array_slice($ItemIds, $Offset);
355 # return list of item type IDs (and possibly types) to caller 367 return $this->OrderList->GetCount();
378 # if resource is in folder 381 # remove item from item order 382 $ItemTypeId = self::GetItemTypeId($ItemType);
383 $this->OrderList->Remove($ItemId, $ItemTypeId);
385 # remove resource from folder locally 386 unset($this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)]);
388 # remove resource from folder in DB 389 $this->DB->Query(
"DELETE FROM FolderItemInts" 390 .
" WHERE FolderId = ".intval($this->
Id)
391 .
" AND ItemId = ".intval($ItemId)
392 .
" AND ItemTypeId = " 393 .($ItemTypeId === NULL ? -1 : intval($ItemTypeId)));
406 $ItemTypeId = self::GetItemTypeId($ItemType);
407 $Index = self::GetCacheIndex($ItemId, $ItemTypeId);
408 $DummyCache = array(
"ItemNote" => $this->ItemNoteCache[$Index]);
410 $Value = $this->DB->UpdateValue(
"FolderItemInts",
"ItemNote", $NewValue,
411 "FolderId = ".intval($this->
Id)
412 .
" AND ItemId = ".intval($ItemId)
413 .
" AND ItemTypeId = " 414 .($ItemTypeId === NULL ? -1 : intval($ItemTypeId)),
417 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = $Value;
431 $ItemTypeId = self::GetItemTypeId($ItemType);
432 return array_key_exists(self::GetCacheIndex($ItemId, $ItemTypeId),
433 $this->ItemNoteCache) ? TRUE : FALSE;
438 # ---- PRIVATE INTERFACE ------------------------------------------------- 443 # folder attributes - these much match field names in Folders DB table 446 private $NormalizedName;
449 private $ContentType;
451 private $ItemNoteCache;
453 private $UpdateValueCache;
455 # item type IDs (indexed by normalized type name) 456 static private $ItemTypeIds;
457 # item type names (indexed by type ID) 458 static private $ItemTypeNames;
460 # content type that indicates folder contains mixed content types 472 # return NULL if TypeName is NULL. 473 if ($TypeName === NULL) {
return NULL; }
475 # make sure item type map is loaded 476 self::LoadItemTypeMap();
478 # normalize item type name 479 $NormalizedTypeName = strtoupper(
480 preg_replace(
"/[^a-zA-Z0-9]/",
"", $TypeName));
482 # if name not already mapped 483 if (!array_key_exists($NormalizedTypeName, self::$ItemTypeIds))
485 # add name to database 487 if (!isset($DB)) { $DB =
new Database(); }
488 $DB->Query(
"INSERT INTO FolderContentTypes SET" 489 .
" TypeName = '".addslashes($TypeName).
"'," 490 .
" NormalizedTypeName = '".addslashes($NormalizedTypeName).
"'");
492 # add name to cached mappings 493 $NewTypeId = $DB->LastInsertId();
494 self::$ItemTypeIds[$NormalizedTypeName] = $NewTypeId;
495 self::$ItemTypeNames[$NewTypeId] = $TypeName;
498 # return item type ID to caller 499 return self::$ItemTypeIds[$NormalizedTypeName];
508 private static function GetItemTypeName($TypeId)
510 # make sure item type map is loaded 511 self::LoadItemTypeMap();
513 # if ID not present in mappings 514 if (!array_key_exists($TypeId, self::$ItemTypeNames))
521 # return item type name to caller 522 return self::$ItemTypeNames[$TypeId];
530 private static function LoadItemTypeMap()
532 # if name-to-number item type map not already loaded 533 if (!isset(self::$ItemTypeIds))
535 # load item type map from database 537 $DB->Query(
"SELECT * FROM FolderContentTypes");
538 self::$ItemTypeIds = array();
539 self::$ItemTypeNames = array();
540 while ($Row = $DB->FetchRow())
542 self::$ItemTypeIds[$Row[
"NormalizedTypeName"]] = $Row[
"TypeId"];
543 self::$ItemTypeNames[$Row[
"TypeId"]] = $Row[
"TypeName"];
553 private function AddItem($ItemOrItemId, $ItemType)
555 # convert item to ID if necessary 556 $ItemId = is_object($ItemOrItemId)
557 ? $ItemOrItemId->Id() : $ItemOrItemId;
559 # convert item type to item type ID 560 $ItemTypeId = self::GetItemTypeId($ItemType);
562 # convert null item type to "no type" value used in database 563 if ($ItemTypeId === NULL) { $ItemTypeId = -1; }
565 # if resource is not already in folder 568 # add resource to folder locally 569 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = NULL;
571 # add resource to folder in DB 572 $this->DB->Query(
"INSERT INTO FolderItemInts SET" 573 .
" FolderId = ".intval($this->
Id)
574 .
", ItemId = ".intval($ItemId)
576 .($ItemTypeId === NULL ? -1 : intval($ItemTypeId)));
586 private static function GetCacheIndex($ItemId, $ItemTypeId)
588 $ItemTypeId = ($ItemTypeId === NULL) ? -1 : $ItemTypeId;
589 return intval($ItemTypeId).
":".intval($ItemId);
599 private function UpdateValue($FieldName, $NewValue)
601 $this->$FieldName = $this->DB->UpdateValue(
"Folders", $FieldName, $NewValue,
602 "FolderId = ".$this->
Id, $this->UpdateValueCache);
603 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.
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.
GetItemCount()
Get number of items in folder.
AppendItems($ItemsOrItemIds, $ItemTypes=NULL)
Add multiple items to the folder at the end.
static GetItemTypeId($TypeName)
ContainsItem($ItemId, $ItemType=NULL)
Check whether specified item is contained in 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.
__construct($FolderId)
Object constructor – load an existing folder.
PrependItem($ItemOrItemId, $ItemType=NULL)
Add item to folder as the first item.
GetItemIds($Offset=NULL, $Length=NULL)
Retrieve array of IDs of items in folder, in the order that they appear in the folder.
Name($NewValue=DB_NOVALUE)
Get/set folder name.