6 # Part of the Collection Workflow Information System (CWIS)
7 # Copyright 2012 Edward Almasy and Internet Scout
8 # http://scout.wisc.edu
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);
87 # take folder out of global folder order
89 $Factory->RemoveItemFromOrder($this->
Id);
91 # remove resource listings from DB
92 $this->DB->Query(
"DELETE FROM FolderItemInts WHERE FolderId = ".$this->
Id);
94 # remove folder listing from DB
95 $this->DB->Query(
"DELETE FROM Folders WHERE FolderId = ".$this->
Id);
99 # ------------------------------------------------------------------------
122 return $this->UpdateValue(
"FolderName", $NewValue);
134 $Name = $this->UpdateValue(
"NormalizedName", $NewValue);
135 # attempt to generate and set new normalized name if none found
138 $Name = $this->UpdateValue(
"NormalizedName",
139 self::NormalizeFolderName($this->
Name()));
151 return preg_replace(
"/[^a-z0-9]/",
"", strtolower($Name));
162 return $this->UpdateValue(
"IsShared", $NewValue);
172 if ($NewValue !==
DB_NOVALUE) { unset($this->Owner); }
173 return intval($this->UpdateValue(
"OwnerId", $NewValue));
183 return $this->UpdateValue(
"FolderNote", $NewValue);
187 # ------------------------------------------------------------------------
203 $TargetItemType = NULL, $NewItemType = NULL)
205 $this->AddItem($NewItemOrItemId, $NewItemType);
206 $this->OrderList->InsertBefore($TargetItemOrItemId, $NewItemOrItemId,
207 self::GetItemTypeId($TargetItemType),
208 self::GetItemTypeId($NewItemType));
223 $TargetItemType = NULL, $NewItemType = NULL)
225 $this->AddItem($NewItemOrItemId, $NewItemType);
226 $this->OrderList->InsertAfter($TargetItemOrItemId, $NewItemOrItemId,
227 self::GetItemTypeId($TargetItemType),
228 self::GetItemTypeId($NewItemType));
239 $this->AddItem($ItemOrItemId, $ItemType);
240 $this->OrderList->Prepend($ItemOrItemId, self::GetItemTypeId($ItemType));
251 $this->AddItem($ItemOrItemId, $ItemType);
252 $this->OrderList->Append($ItemOrItemId, self::GetItemTypeId($ItemType));
264 # retrieve item ordered list of type IDs
265 $ItemIds = $this->OrderList->GetIds();
267 # if this is a mixed-item-type folder
268 if ($this->ContentType == self::MIXEDCONTENT)
270 # convert item type IDs to corresponding type names
271 $NewItemIds = array();
272 foreach ($ItemIds as $ItemInfo)
274 $NewItemIds[] = array(
275 "ID" => $ItemInfo[
"ID"],
276 "Type" => self::GetItemTypeName($ItemInfo[
"Type"]),
279 $ItemIds = $NewItemIds;
282 # return list of item type IDs (and possibly types) to caller
294 # if resource is in folder
297 # remove item from item order
298 $ItemTypeId = self::GetItemTypeId($ItemType);
299 $this->OrderList->Remove($ItemId, $ItemTypeId);
301 # remove resource from folder locally
302 unset($this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)]);
304 # remove resource from folder in DB
305 $this->DB->Query(
"DELETE FROM FolderItemInts"
306 .
" WHERE FolderId = ".intval($this->
Id)
307 .
" AND ItemId = ".intval($ItemId)
308 .
" AND ItemTypeId = ".intval($ItemTypeId));
321 $ItemTypeId = self::GetItemTypeId($ItemType);
322 $Index = self::GetCacheIndex($ItemId, $ItemTypeId);
323 $DummyCache = array(
"ItemNote" => $this->ItemNoteCache[$Index]);
325 $Value = $this->DB->UpdateValue(
"FolderItemInts",
"ItemNote", $NewValue,
326 "FolderId = ".intval($this->
Id)
327 .
" AND ItemId = ".intval($ItemId)
328 .
" AND ItemTypeId = ".intval($ItemTypeId),
331 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = $Value;
344 $ItemTypeId = self::GetItemTypeId($ItemType);
345 return array_key_exists(self::GetCacheIndex($ItemId, $ItemTypeId),
346 $this->ItemNoteCache) ? TRUE : FALSE;
351 # ---- 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
378 # map item type string to numerical value
379 # (not private because FolderFactory needs it)
380 static function GetItemTypeId($TypeName)
382 # return "no type" ID if null passed in
383 if ($TypeName === NULL) {
return -1; }
385 # make sure item type map is loaded
386 self::LoadItemTypeMap();
388 # normalize item type name
389 $NormalizedTypeName = strtoupper(
390 preg_replace(
"/[^a-zA-Z0-9]/",
"", $TypeName));
392 # if name not already mapped
393 if (!array_key_exists($NormalizedTypeName, self::$ItemTypeIds))
395 # add name to database
396 if (!isset($DB)) { $DB =
new Database(); }
397 $DB->Query(
"INSERT INTO FolderContentTypes SET"
398 .
" TypeName = '".addslashes($TypeName).
"',"
399 .
" NormalizedTypeName = '".addslashes($NormalizedTypeName).
"'");
401 # add name to cached mappings
402 $NewTypeId = $DB->LastInsertId(
"FolderContentTypes");
403 self::$ItemTypeIds[$NormalizedTypeName] = $NewTypeId;
404 self::$ItemTypeNames[$NewTypeId] = $TypeName;
407 # return item type ID to caller
408 return self::$ItemTypeIds[$NormalizedTypeName];
412 # map item type numerical value to string
413 private static function GetItemTypeName($TypeId)
415 # make sure item type map is loaded
416 self::LoadItemTypeMap();
418 # if ID not present in mappings
419 if (!array_key_exists($TypeId, self::$ItemTypeNames))
426 # return item type name to caller
427 return self::$ItemTypeNames[$TypeId];
431 # load item type map from database
432 private static function LoadItemTypeMap()
434 # if name-to-number item type map not already loaded
435 if (!isset(self::$ItemTypeIds))
437 # load item type map from database
439 $DB->Query(
"SELECT * FROM FolderContentTypes");
440 self::$ItemTypeIds = array();
441 self::$ItemTypeNames = array();
442 while ($Row = $DB->FetchRow())
444 self::$ItemTypeIds[$Row[
"NormalizedTypeName"]] = $Row[
"TypeId"];
445 self::$ItemTypeNames[$Row[
"TypeId"]] = $Row[
"TypeName"];
450 # add resource to folder (does not add to ordered list)
451 private function AddItem($ItemOrItemId, $ItemType)
453 # convert item to ID if necessary
454 $ItemId = is_object($ItemOrItemId)
455 ? $ItemOrItemId->Id() : $ItemOrItemId;
457 # convert item type to item type ID
458 $ItemTypeId = self::GetItemTypeId($ItemType);
460 # convert null item type to "no type" value used in database
461 if ($ItemTypeId === NULL) { $ItemTypeId = -1; }
463 # if resource is not already in folder
466 # add resource to folder locally
467 $this->ItemNoteCache[self::GetCacheIndex($ItemId, $ItemTypeId)] = NULL;
469 # add resource to folder in DB
470 $this->DB->Query(
"INSERT INTO FolderItemInts SET"
471 .
" FolderId = ".intval($this->
Id)
472 .
", ItemId = ".intval($ItemId)
473 .
", ItemTypeId = ".intval($ItemTypeId));
477 # get index to be used with item note cache array
478 private static function GetCacheIndex($ItemId, $ItemTypeId)
480 $ItemTypeId = ($ItemTypeId === NULL) ? -1 : $ItemTypeId;
481 return intval($ItemTypeId).
":".intval($ItemId);
484 # get/set value in database
485 private function UpdateValue($FieldName, $NewValue)
487 $this->$FieldName = $this->DB->UpdateValue(
"Folders", $FieldName, $NewValue,
488 "FolderId = ".$this->
Id, $this->UpdateValueCache);
489 return $this->$FieldName;