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));
264 # convert ItemTypes to an array if it wasn't one
265 if (!is_array($ItemTypes))
267 $NewItemTypes = array();
268 foreach ($ItemsOrItemIds as $Id)
270 $NewItemTypes[] = $ItemTypes;
272 $ItemTypes = $NewItemTypes;
277 foreach ($ItemsOrItemIds as $ItemOrId)
279 $ItemIds[] = is_object($ItemOrId) ? $ItemOrId->Id() : $ItemOrId;
282 # add all the itmes to our folder
283 foreach ($ItemIds as $Index => $ItemId)
285 $this->AddItem( $ItemId, $ItemTypes[ $Index ] );
288 # and add them to our ordering list
289 $this->OrderList->Append($ItemIds, $ItemTypes);
301 # retrieve item ordered list of type IDs
302 $ItemIds = $this->OrderList->GetIds();
304 # if this is a mixed-item-type folder
305 if ($this->ContentType == self::MIXEDCONTENT)
307 # convert item type IDs to corresponding type names
308 $NewItemIds = array();
309 foreach ($ItemIds as $ItemInfo)
311 $NewItemIds[] = array(
312 "ID" => $ItemInfo[
"ID"],
313 "Type" => self::GetItemTypeName($ItemInfo[
"Type"]),
316 $ItemIds = $NewItemIds;
319 # return list of item type IDs (and possibly types) to caller
331 return $this->OrderList->GetCount();
342 # if resource is in folder
345 # remove item from item order
346 $ItemTypeId = self::GetItemTypeId($ItemType);
347 $this->OrderList->Remove($ItemId, $ItemTypeId);
349 # remove resource from folder locally
350 unset($this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)]);
352 # remove resource from folder in DB
353 $this->DB->Query(
"DELETE FROM FolderItemInts"
354 .
" WHERE FolderId = ".intval($this->
Id)
355 .
" AND ItemId = ".intval($ItemId)
356 .
" AND ItemTypeId = ".intval($ItemTypeId));
369 $ItemTypeId = self::GetItemTypeId($ItemType);
370 $Index = self::GetCacheIndex($ItemId, $ItemTypeId);
371 $DummyCache = array(
"ItemNote" => $this->ItemNoteCache[$Index]);
373 $Value = $this->DB->UpdateValue(
"FolderItemInts",
"ItemNote", $NewValue,
374 "FolderId = ".intval($this->
Id)
375 .
" AND ItemId = ".intval($ItemId)
376 .
" AND ItemTypeId = ".intval($ItemTypeId),
379 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = $Value;
392 $ItemTypeId = self::GetItemTypeId($ItemType);
393 return array_key_exists(self::GetCacheIndex($ItemId, $ItemTypeId),
394 $this->ItemNoteCache) ? TRUE : FALSE;
399 # ---- PRIVATE INTERFACE -------------------------------------------------
404 # folder attributes - these much match field names in Folders DB table
407 private $NormalizedName;
410 private $ContentType;
412 private $ItemNoteCache;
414 private $UpdateValueCache;
416 # item type IDs (indexed by normalized type name)
417 static private $ItemTypeIds;
418 # item type names (indexed by type ID)
419 static private $ItemTypeNames;
421 # content type that indicates folder contains mixed content types
433 # return "no type" ID if null passed in
434 if ($TypeName === NULL) {
return -1; }
436 # make sure item type map is loaded
437 self::LoadItemTypeMap();
439 # normalize item type name
440 $NormalizedTypeName = strtoupper(
441 preg_replace(
"/[^a-zA-Z0-9]/",
"", $TypeName));
443 # if name not already mapped
444 if (!array_key_exists($NormalizedTypeName, self::$ItemTypeIds))
446 # add name to database
447 if (!isset($DB)) { $DB =
new Database(); }
448 $DB->Query(
"INSERT INTO FolderContentTypes SET"
449 .
" TypeName = '".addslashes($TypeName).
"',"
450 .
" NormalizedTypeName = '".addslashes($NormalizedTypeName).
"'");
452 # add name to cached mappings
453 $NewTypeId = $DB->LastInsertId();
454 self::$ItemTypeIds[$NormalizedTypeName] = $NewTypeId;
455 self::$ItemTypeNames[$NewTypeId] = $TypeName;
458 # return item type ID to caller
459 return self::$ItemTypeIds[$NormalizedTypeName];
468 private static function GetItemTypeName($TypeId)
470 # make sure item type map is loaded
471 self::LoadItemTypeMap();
473 # if ID not present in mappings
474 if (!array_key_exists($TypeId, self::$ItemTypeNames))
481 # return item type name to caller
482 return self::$ItemTypeNames[$TypeId];
490 private static function LoadItemTypeMap()
492 # if name-to-number item type map not already loaded
493 if (!isset(self::$ItemTypeIds))
495 # load item type map from database
497 $DB->Query(
"SELECT * FROM FolderContentTypes");
498 self::$ItemTypeIds = array();
499 self::$ItemTypeNames = array();
500 while ($Row = $DB->FetchRow())
502 self::$ItemTypeIds[$Row[
"NormalizedTypeName"]] = $Row[
"TypeId"];
503 self::$ItemTypeNames[$Row[
"TypeId"]] = $Row[
"TypeName"];
513 private function AddItem($ItemOrItemId, $ItemType)
515 # convert item to ID if necessary
516 $ItemId = is_object($ItemOrItemId)
517 ? $ItemOrItemId->Id() : $ItemOrItemId;
519 # convert item type to item type ID
520 $ItemTypeId = self::GetItemTypeId($ItemType);
522 # convert null item type to "no type" value used in database
523 if ($ItemTypeId === NULL) { $ItemTypeId = -1; }
525 # if resource is not already in folder
528 # add resource to folder locally
529 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = NULL;
531 # add resource to folder in DB
532 $this->DB->Query(
"INSERT INTO FolderItemInts SET"
533 .
" FolderId = ".intval($this->
Id)
534 .
", ItemId = ".intval($ItemId)
535 .
", ItemTypeId = ".intval($ItemTypeId));
545 private static function GetCacheIndex($ItemId, $ItemTypeId)
547 $ItemTypeId = ($ItemTypeId === NULL) ? -1 : $ItemTypeId;
548 return intval($ItemTypeId).
":".intval($ItemId);
558 private function UpdateValue($FieldName, $NewValue)
560 $this->$FieldName = $this->DB->UpdateValue(
"Folders", $FieldName, $NewValue,
561 "FolderId = ".$this->
Id, $this->UpdateValueCache);
562 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.
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.
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.