CWIS Developer Documentation

- Home
- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

ControlledName.php
Go to the documentation of this file.
1 <?PHP
2 #
3 # FILE: ControlledName.php
4 #
5 # Part of the Collection Workflow Integration System (CWIS)
6 # Copyright 2001-2013 Edward Almasy and Internet Scout Research Group
7 # http://scout.wisc.edu/cwis/
8 #
9
14 class ControlledName {
15
16 # ---- PUBLIC INTERFACE --------------------------------------------------
17 /*@{*/
20 const STATUS_OK = 0;
22 const STATUS_INVALID_ID = 1;
24 const STATUS_EXISTS = 2;
39 public function __construct($NameId, $Name = NULL, $FieldId = NULL,
40 $QualifierId = "NULL", $VariantName = NULL)
41 {
42 # assume everything will turn out okay
43 $this->ErrorStatus = self::STATUS_OK;
44
45 # create DB handle for our use
46 $this->DB = new Database();
47 $DB =& $this->DB;
48
49 # remove whitespace padding
50 $Name = trim($Name);
51 $VariantName = trim($VariantName);
52
53 # look for passed in name and type
54 if (!empty($Name) && !empty($FieldId))
55 {
56 $DB->Query("SELECT * FROM ControlledNames".
57 " WHERE ControlledName = \"".addslashes($Name)."\"".
58 " AND FieldId = ".intval($FieldId));
59
60 while ($this->DBFields = $DB->FetchRow())
61 {
62 # this controlled name already exists
63 if ($this->DBFields["ControlledName"] == $Name)
64 {
65 $this->ErrorStatus = self::STATUS_EXISTS;
66 $NameId = $this->DBFields["ControlledNameId"];
67
68 # cache the variant name separately
69 $VN = $DB->Query("SELECT VariantName FROM VariantNames".
70 " WHERE ControlledNameId = ".
71 $this->DBFields["ControlledNameId"], "VariantName");
72
73 $this->DBFields["VariantName"] = $VN;
74 break;
75 }
76 }
77 # controlled name not found, create it
78 if ($this->ErrorStatus == self::STATUS_OK)
79 {
80 # add new controlled name
81 $DB->Query("INSERT INTO ControlledNames ".
82 "(FieldId, ControlledName, QualifierId)".
83 " VALUES (".intval($FieldId).", '".addslashes($Name)
84 ."', ".intval($QualifierId).")");
85
86 # get name ID for new controlled name
87 $NameId = $DB->LastInsertId();
88
89 # check for Variant
90 if (!empty($VariantName))
91 {
92 $DB->Query("INSERT INTO VariantNames ".
93 "(ControlledNameId, VariantName) ".
94 "VALUES (".intval($NameId).", '"
95 .addslashes($VariantName)."') ");
96 }
97 }
98 }
99 # Name Id passed in, look it up
100 if (!empty($NameId) && $NameId != -1)
101 {
102 $DB->Query("SELECT * FROM ControlledNames".
103 " WHERE ControlledNameId = ".intval($NameId));
104 $this->DBFields = $DB->FetchRow();
105
106 # cache the variant name separately
107 $VN = $DB->Query("SELECT VariantName FROM VariantNames".
108 " WHERE ControlledNameId = ".intval($NameId), "VariantName");
109
110 $this->DBFields["VariantName"] = $VN;
111 }
112
113 # save supplied or generated controlled name ID
114 $this->Id = intval($NameId);
115
116 # set error status if controlled name info not loaded
117 if (!array_key_exists("ControlledNameId", $this->DBFields)
118 || ($this->DBFields["ControlledNameId"] != $this->Id))
119 {
120 $this->ErrorStatus = self::STATUS_INVALID_ID;
121 }
122 }
123
128 public function Status()
129 {
130 return $this->ErrorStatus;
131 }
132
137 public function Id()
138 {
139 return $this->Id;
140 }
141
147 public function Name($NewValue = DB_NOVALUE)
148 {
149 return $this->UpdateValue("ControlledName", $NewValue);
150 }
151
157 public function VariantName($NewValue = DB_NOVALUE)
158 {
159 return $this->UpdateVariantValue("VariantName", $NewValue);
160 }
161
167 public function FieldId($NewValue = DB_NOVALUE)
168 {
169 return $this->UpdateValue("FieldId", $NewValue);
170 }
171
177 public function QualifierId($NewValue = DB_NOVALUE)
178 {
179 return $this->UpdateValue("QualifierId", $NewValue);
180 }
181
187 public function Variant($NewValue = DB_NOVALUE)
188 {
189 return $this->VariantName($NewValue);
190 }
191
197 public function Qualifier($NewValue = DB_NOVALUE)
198 {
199 # if new qualifier supplied
200 if ($NewValue !== DB_NOVALUE)
201 {
202 # set new qualifier ID
203 $this->QualifierId($NewValue->Id());
204
205 # use new qualifier for return value
206 $Qualifier = $NewValue;
207 }
208 else
209 {
210 # if qualifier is available
211 if ($this->QualifierId() !== NULL)
212 {
213 # create qualifier object using stored ID
214 $Qualifier = new Qualifier($this->QualifierId());
215
216 # if ID was zero and no name available for qualifieR
217 # (needed because some controlled name records in DB
218 # have 0 instead of NULL when no controlled name assigned)
219 # (NOTE: this is problematic if there is a qualifier with an
220 # ID value of 0!!!)
221 if (($this->QualifierId() == 0) && !strlen($Qualifier->Name()))
222 {
223 # return NULL to indicate no qualifier
224 $Qualifier = NULL;
225 }
226 }
227 else
228 {
229 # return NULL to indicate no qualifier
230 $Qualifier = NULL;
231 }
232 }
233
234 # return qualifier to caller
235 return $Qualifier;
236 }
237
244 static function SearchForControlledName($ControlledName, $FieldId)
245 {
246 $Database = new Database();
247
248 # query for the controlled name
249 $Database->Query("
250 SELECT ControlledNameId FROM
251 ControlledNames WHERE FieldId='".addslashes($FieldId)."'
252 AND ControlledName='".addslashes($ControlledName)."'");
253
254 # return the controlled name IDs found, if any
255 return $Database->FetchColumn("ControlledNameId");
256 }
257
262 public function InUse()
263 {
264 return $this->DB->Query("SELECT COUNT(*) AS Count FROM ".
265 "ResourceNameInts WHERE ControlledNameId = ".$this->Id, "Count");
266 }
267
272 public function GetAssociatedResources()
273 {
274 $this->DB->Query(
275 "SELECT ResourceId FROM ResourceNameInts "
276 ."WHERE ControlledNameId = ".$this->Id);
277
278 return $this->DB->FetchColumn("ResourceId");
279 }
280
286 public function RemapTo($NewNameId)
287 {
288 # Get a list of resources associated with the new name
289 $this->DB->Query("SELECT ResourceId FROM ResourceNameInts "
290 ."WHERE ControlledNameId = ".intval($NewNameId));
291 $NewNameResources = array();
292 while ($Row = $this->DB->FetchRow())
293 {
294 $NewNameResources[$Row["ResourceId"]]=1;
295 }
296
297 # Get a list of resources associated with the old name
298 $this->DB->Query("SELECT ResourceId FROM ResourceNameInts "
299 ."WHERE ControlledNameId = ".intval($this->Id));
300 $OldNameResources = array();
301 while ($Row = $this->DB->FetchRow())
302 {
303 $OldNameResources[]= $Row["ResourceId"];
304 }
305
306 # Foreach of the old name resources, check to see if it's already
307 # associated with the new name. If not, associate it.
308 foreach ($OldNameResources as $ResourceId)
309 {
310 if (!isset($NewNameResources[$ResourceId]))
311 {
312 $this->DB->Query("INSERT INTO ResourceNameInts "
313 ."(ResourceId, ControlledNameId) VALUES "
314 ."(".intval($ResourceId).",".intval($NewNameId).")");
315 }
316 }
317
318 # Clear out all the associations to the old name
319 $this->DB->Query("DELETE FROM ResourceNameInts WHERE ControlledNameId = "
320 .intval($this->Id));
321 }
322
326 public function UpdateLastAssigned()
327 {
328 $this->DB->Query("UPDATE ControlledNames SET LastAssigned=NOW() "
329 ."WHERE ControlledNameId=".intval($this->Id));
330 }
331
338 public function Delete($DeleteIfHasResources = FALSE)
339 {
340 $DB =& $this->DB;
341
342 if ($DeleteIfHasResources || !$this->InUse())
343 {
344 # delete this controlled name
345 $DB->Query("DELETE FROM ControlledNames WHERE ControlledNameId=".
346 $this->Id);
347
348 # delete associated variant name
349 $DB->Query("DELETE FROM VariantNames WHERE ControlledNameId=".
350 $this->Id);
351
352 if ($DeleteIfHasResources)
353 {
354 $DB->Query("DELETE FROM ResourceNameInts WHERE ".
355 "ControlledNameId=".$this->Id);
356 }
357 }
358 }
359
360 # ---- PRIVATE INTERFACE -------------------------------------------------
361
362 private $DB;
363 private $DBFields;
364 private $Id;
365 private $ErrorStatus;
366
374 private function UpdateValue($FieldName, $NewValue)
375 {
376 return $this->DB->UpdateValue("ControlledNames", $FieldName,
377 $NewValue, "ControlledNameId = ".$this->Id,
378 $this->DBFields, TRUE);
379 }
380
388 private function UpdateVariantValue($FieldName, $NewValue)
389 {
390 if (!empty($NewValue))
391 {
392 # see if variant name exists for the controlled Name
393 $this->DB->Query("SELECT * from VariantNames WHERE ".
394 "ControlledNameId = ".$this->Id);
395
396 # variant name exists so do an update
397 if ($this->DB->NumRowsSelected() > 0)
398 {
399 return $this->DB->UpdateValue("VariantNames",
400 $FieldName, $NewValue,
401 "ControlledNameId = ".$this->Id,
402 $this->DBFields, TRUE);
403 }
404 # no variant name so do an insert
405 else if ($NewValue != DB_NOVALUE)
406 {
407 $this->DB->Query("INSERT into VariantNames ".
408 "(VariantName, ControlledNameId) VALUES ".
409 "('".addslashes($NewValue)."', ".$this->Id.")");
410 }
411 }
412 # delete variant name
413 else
414 {
415 $this->DB->Query("Delete from VariantNames where ".
416 "ControlledNameId = ".$this->Id);
417 }
418 }
419 }
ControlledName\RemapTo
RemapTo($NewNameId)
Change all currently associated Resources to be instead associated with another ControlledName.
Definition: ControlledName.php:286
ControlledName\__construct
__construct($NameId, $Name=NULL, $FieldId=NULL, $QualifierId="NULL", $VariantName=NULL)
Class constructor.
Definition: ControlledName.php:39
ControlledName\Name
Name($NewValue=DB_NOVALUE)
Get or set the controlled vocabulary term.
Definition: ControlledName.php:147
ControlledName\GetAssociatedResources
GetAssociatedResources()
Get resourceIds associated with this ControlledName.
Definition: ControlledName.php:272
ControlledName\Delete
Delete($DeleteIfHasResources=FALSE)
Remove ControlledName (and any accompanying associations from database.
Definition: ControlledName.php:338
ControlledName\SearchForControlledName
static SearchForControlledName($ControlledName, $FieldId)
Check if the given controlled name already exists for a given field ID.
Definition: ControlledName.php:244
Database
SQL database abstraction object with smart query caching.
Definition: Database.php:22
ControlledName\VariantName
VariantName($NewValue=DB_NOVALUE)
Get or set any variant terms for this controlled name .
Definition: ControlledName.php:157
ControlledName
Metadata type representing non-hierarchical controlled vocabulary values.
Definition: ControlledName.php:14
ControlledName\Qualifier
Qualifier($NewValue=DB_NOVALUE)
Get or set the Qualifier associated with this term via object.
Definition: ControlledName.php:197
PHP
PHP
Definition: RSSClient--Test.php:12
DB_NOVALUE
const DB_NOVALUE
Definition: Database.php:1396
ControlledName\Id
Id()
Get ID.
Definition: ControlledName.php:137
ControlledName\STATUS_OK
const STATUS_OK
Successful execution.
Definition: ControlledName.php:20
ControlledName\FieldId
FieldId($NewValue=DB_NOVALUE)
Get or set the MetadataField associated with this term.
Definition: ControlledName.php:167
ControlledName\Variant
Variant($NewValue=DB_NOVALUE)
Get or set the controlled name variant.
Definition: ControlledName.php:187
ControlledName\STATUS_INVALID_ID
const STATUS_INVALID_ID
No ControlledName exists with specified ID.
Definition: ControlledName.php:22
ControlledName\QualifierId
QualifierId($NewValue=DB_NOVALUE)
Get or set the Qualifier associated with this term via ID.
Definition: ControlledName.php:177
ControlledName\STATUS_EXISTS
const STATUS_EXISTS
ControlledName already exists with this term.
Definition: ControlledName.php:24
ControlledName\InUse
InUse()
See if ControlledName is currently associated with any Resources.
Definition: ControlledName.php:262
ControlledName\Status
Status()
Check success of constructor.
Definition: ControlledName.php:128
ControlledName\UpdateLastAssigned
UpdateLastAssigned()
Update the LastAssigned timestamp for this classification.
Definition: ControlledName.php:326