CWIS Developer Documentation
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 
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 }
RemapTo($NewNameId)
Change all currently associated Resources to be instead associated with another ControlledName.
__construct($NameId, $Name=NULL, $FieldId=NULL, $QualifierId="NULL", $VariantName=NULL)
Class constructor.
Name($NewValue=DB_NOVALUE)
Get or set the controlled vocabulary term.
GetAssociatedResources()
Get resourceIds associated with this ControlledName.
Delete($DeleteIfHasResources=FALSE)
Remove ControlledName (and any accompanying associations from database.
static SearchForControlledName($ControlledName, $FieldId)
Check if the given controlled name already exists for a given field ID.
SQL database abstraction object with smart query caching.
Definition: Database.php:22
VariantName($NewValue=DB_NOVALUE)
Get or set any variant terms for this controlled name .
Metadata type representing non-hierarchical controlled vocabulary values.
Qualifier($NewValue=DB_NOVALUE)
Get or set the Qualifier associated with this term via object.
const DB_NOVALUE
Definition: Database.php:1396
const STATUS_OK
Successful execution.
FieldId($NewValue=DB_NOVALUE)
Get or set the MetadataField associated with this term.
Variant($NewValue=DB_NOVALUE)
Get or set the controlled name variant.
const STATUS_INVALID_ID
No ControlledName exists with specified ID.
QualifierId($NewValue=DB_NOVALUE)
Get or set the Qualifier associated with this term via ID.
const STATUS_EXISTS
ControlledName already exists with this term.
InUse()
See if ControlledName is currently associated with any Resources.
Status()
Check success of constructor.
UpdateLastAssigned()
Update the LastAssigned timestamp for this classification.