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  function ControlledName($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  function Status() { return $this->ErrorStatus; }
129 
134  function Id() { return $this->Id; }
135 
141  function Name($NewValue = DB_NOVALUE)
142  { return $this->UpdateValue("ControlledName", $NewValue); }
143 
149  function VariantName($NewValue = DB_NOVALUE)
150  { return $this->UpdateVariantValue("VariantName", $NewValue); }
151 
157  function FieldId($NewValue = DB_NOVALUE)
158  { return $this->UpdateValue("FieldId", $NewValue); }
159 
165  function QualifierId($NewValue = DB_NOVALUE)
166  { return $this->UpdateValue("QualifierId", $NewValue); }
167 
173  function Variant($NewValue = DB_NOVALUE)
174  { return $this->VariantName($NewValue); }
175 
181  function Qualifier($NewValue = DB_NOVALUE)
182  {
183  # if new qualifier supplied
184  if ($NewValue !== DB_NOVALUE)
185  {
186  # set new qualifier ID
187  $this->QualifierId($NewValue->Id());
188 
189  # use new qualifier for return value
190  $Qualifier = $NewValue;
191  }
192  else
193  {
194  # if qualifier is available
195  if ($this->QualifierId() !== NULL)
196  {
197  # create qualifier object using stored ID
198  $Qualifier = new Qualifier($this->QualifierId());
199 
200  # if ID was zero and no name available for qualifieR
201  # (needed because some controlled name records in DB
202  # have 0 instead of NULL when no controlled name assigned)
203  # (NOTE: this is problematic if there is a qualifier with an
204  # ID value of 0!!!)
205  if (($this->QualifierId() == 0) && !strlen($Qualifier->Name()))
206  {
207  # return NULL to indicate no qualifier
208  $Qualifier = NULL;
209  }
210  }
211  else
212  {
213  # return NULL to indicate no qualifier
214  $Qualifier = NULL;
215  }
216  }
217 
218  # return qualifier to caller
219  return $Qualifier;
220  }
221 
228  static function SearchForControlledName($ControlledName, $FieldId)
229  {
230  $Database = new Database();
231 
232  # query for the controlled name
233  $Database->Query("
234  SELECT ControlledNameId FROM
235  ControlledNames WHERE FieldId='".addslashes($FieldId)."'
236  AND ControlledName='".addslashes($ControlledName)."'");
237 
238  # return the controlled name IDs found, if any
239  return $Database->FetchColumn("ControlledNameId");
240  }
241 
246  function InUse()
247  {
248  return $this->DB->Query("SELECT COUNT(*) AS Count FROM ".
249  "ResourceNameInts WHERE ControlledNameId = ".$this->Id, "Count");
250  }
251 
257  function RemapTo($NewNameId)
258  {
259  # Get a list of resources associated with the new name
260  $this->DB->Query("SELECT ResourceId FROM ResourceNameInts "
261  ."WHERE ControlledNameId = ".intval($NewNameId));
262  $NewNameResources = array();
263  while ($Row = $this->DB->FetchRow())
264  {
265  $NewNameResources[$Row["ResourceId"]]=1;
266  }
267 
268  # Get a list of resources associated with the old name
269  $this->DB->Query("SELECT ResourceId FROM ResourceNameInts "
270  ."WHERE ControlledNameId = ".intval($this->Id));
271  $OldNameResources = array();
272  while ($Row = $this->DB->FetchRow())
273  {
274  $OldNameResources []= $Row["ResourceId"];
275  }
276 
277  # Foreach of the old name resources, check to see if it's already
278  # associated with the new name. If not, associate it.
279  foreach ($OldNameResources as $ResourceId)
280  {
281  if (!isset($NewNameResources[$ResourceId]))
282  {
283  $this->DB->Query("INSERT INTO ResourceNameInts "
284  ."(ResourceId, ControlledNameId) VALUES "
285  ."(".intval($ResourceId).",".intval($NewNameId).")");
286  }
287  }
288 
289  # Clear out all the associations to the old name
290  $this->DB->Query("DELETE FROM ResourceNameInts WHERE ControlledNameId = "
291  .intval($this->Id));
292  }
293 
298  {
299  $this->DB->Query("UPDATE ControlledNames SET LastAssigned=NOW() "
300  ."WHERE ControlledNameId=".intval($this->Id));
301  }
302 
309  function Delete($DeleteIfHasResources = FALSE)
310  {
311  $DB =& $this->DB;
312 
313  if ($DeleteIfHasResources || !$this->InUse())
314  {
315  # delete this controlled name
316  $DB->Query("DELETE FROM ControlledNames WHERE ControlledNameId=".
317  $this->Id);
318 
319  # delete associated variant name
320  $DB->Query("DELETE FROM VariantNames WHERE ControlledNameId=".
321  $this->Id);
322 
323  if ($DeleteIfHasResources)
324  {
325  $DB->Query("DELETE FROM ResourceNameInts WHERE ".
326  "ControlledNameId=".$this->Id);
327  }
328  }
329  }
330 
331  # ---- PRIVATE INTERFACE -------------------------------------------------
332 
333  private $DB;
334  private $DBFields;
335  private $Id;
336  private $ErrorStatus;
337 
345  private function UpdateValue($FieldName, $NewValue)
346  {
347  return $this->DB->UpdateValue("ControlledNames", $FieldName,
348  $NewValue, "ControlledNameId = ".$this->Id,
349  $this->DBFields, TRUE);
350  }
351 
359  private function UpdateVariantValue($FieldName, $NewValue)
360  {
361  if (!empty($NewValue))
362  {
363  # see if variant name exists for the controlled Name
364  $this->DB->Query("SELECT * from VariantNames WHERE ".
365  "ControlledNameId = ".$this->Id);
366 
367  # variant name exists so do an update
368  if ($this->DB->NumRowsSelected() > 0)
369  {
370  return $this->DB->UpdateValue("VariantNames",
371  $FieldName, $NewValue,
372  "ControlledNameId = ".$this->Id,
373  $this->DBFields, TRUE);
374  }
375  # no variant name so do an insert
376  else if ($NewValue != DB_NOVALUE)
377  {
378  $this->DB->Query("INSERT into VariantNames ".
379  "(VariantName, ControlledNameId) VALUES ".
380  "('".addslashes($NewValue)."', ".$this->Id.")");
381  }
382  }
383  # delete variant name
384  else
385  {
386  $this->DB->Query("Delete from VariantNames where ".
387  "ControlledNameId = ".$this->Id);
388  }
389  }
390 }
RemapTo($NewNameId)
Change all currently associated Resources to be instead associated with another ControlledName.
Name($NewValue=DB_NOVALUE)
Get or set the controlled vocabulary term.
ControlledName($NameId, $Name=NULL, $FieldId=NULL, $QualifierId="NULL", $VariantName=NULL)
Class constructor.
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.
const DB_NOVALUE
VariantName($NewValue=DB_NOVALUE)
Get or set any variant terms for this controlled name .
Metadata type representing non-hierarchical controlled vocabulary values.
PHP
Definition: OAIClient.php:39
Qualifier($NewValue=DB_NOVALUE)
Get or set the Qualifier associated with this term via object.
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.