#There are 223 defined entities.

import string

import xml.dom.minidom

from random import choice

from django.contrib.gis.geos import *

from django.contrib.gis.db import models

def getRandom(length=8, chars=string.letters + string.digits):

  return ''.join([choice(chars) for i in range(length)])

def getRandomString():

  return getRandom(45)

def getRandomText():

  return getRandom(450)

def getRandomInt():

  return int(getRandom(4,string.digits))

def getRandomFloat():

  return float(getRandom(4,string.digits))

def getRandomBool():

  return choice(['true','false'])

#Not actually random, but not worth the time

def getRandomDate():

  return '2007-07-16'

def getRandomTime():

  return '08:30:00'

class EntryInfo(models.Model):

  creationDate = models.DateTimeField(auto_now_add=True)

  lastUpdatedDate = models.DateTimeField(auto_now=True)

  dataSource = models.CharField(max_length=255, db_index=True)

class taxonNames(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  def exportVegX(self,myNode,doc):

    for childRef in self.ScientificName_taxonNames_id.all():

      newEl = doc.createElement('taxonName')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      #These are the elements that refer to this one

      if cName == 'taxonName':

        newEl = ScientificName().retrieveOrNew(child)

        newEl.taxonNames_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'ScientificName' not in usedObjectsStack:

      usedObjectsStack.append('ScientificName')

      newEl = doc.createElement('taxonName')

      childRef = ScientificName()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return taxonNames()

  class Meta:

    db_table = u'v_taxonnames_lc'

class taxonConcepts(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  def exportVegX(self,myNode,doc):

    for childRef in self.TaxonConceptType_taxonConcepts_id.all():

      newEl = doc.createElement('taxonConcept')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      #These are the elements that refer to this one

      if cName == 'taxonConcept':

        newEl = TaxonConceptType().retrieveOrNew(child)

        newEl.taxonConcepts_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'TaxonConceptType' not in usedObjectsStack:

      usedObjectsStack.append('TaxonConceptType')

      newEl = doc.createElement('taxonConcept')

      childRef = TaxonConceptType()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return taxonConcepts()

  class Meta:

    db_table = u'v_taxonconcepts_lc'

class TaxonNames(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  def exportVegX(self,myNode,doc):

    for childRef in self.ScientificName_TaxonNames_id.all():

      newEl = doc.createElement('TaxonName')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      #These are the elements that refer to this one

      if cName == 'TaxonName':

        newEl = ScientificName().retrieveOrNew(child)

        newEl.TaxonNames_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'ScientificName' not in usedObjectsStack:

      usedObjectsStack.append('ScientificName')

      newEl = doc.createElement('TaxonName')

      childRef = ScientificName()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return TaxonNames()

  class Meta:

    db_table = u'v_taxonnames_uc'

class TaxonConcepts(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  def exportVegX(self,myNode,doc):

    for childRef in self.TaxonConceptType_TaxonConcepts_id.all():

      newEl = doc.createElement('TaxonConcept')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      #These are the elements that refer to this one

      if cName == 'TaxonConcept':

        newEl = TaxonConceptType().retrieveOrNew(child)

        newEl.TaxonConcepts_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'TaxonConceptType' not in usedObjectsStack:

      usedObjectsStack.append('TaxonConceptType')

      newEl = doc.createElement('TaxonConcept')

      childRef = TaxonConceptType()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return TaxonConcepts()

  class Meta:

    db_table = u'v_taxonconcepts_uc'

class eml_access(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  access = models.ForeignKey('AccessType', related_name='eml_access_access', null=True, blank=True) #Complex one2Many

  def exportVegX(self,myNode,doc):

    if self.access != None:

      newEl = doc.createElement('access')

      myNode.appendChild(self.access.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'access':

        newEl = AccessType().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.access = newEl

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'AccessType' not in usedObjectsStack:

      usedObjectsStack.append('AccessType')

      newEl = doc.createElement('access')

      newElObj = AccessType()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return eml_access()

class AccessType(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  ReferencesGroup = models.ForeignKey('ReferencesGroup', related_name='AccessType_ReferencesGroup', null=True, blank=True) #Complex one2Many

  allow = models.ManyToManyField('AccessRule',related_name='AccessType_allow')

  deny = models.ManyToManyField('AccessRule',related_name='AccessType_deny')

  attr_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)

  attr_system = models.CharField(max_length=255, null=True, blank=True)

  attr_scope = models.CharField(max_length=255, null=True, blank=True, default = 'document')

  attr_order = models.CharField(max_length=255, null=True, blank=True, default = 'allowFirst')

  attr_authSystem = models.CharField(max_length=255)

  def exportVegX(self,myNode,doc):

    if self.attr_id != None:

      newAttr = doc.createAttribute('id')

      newAttr.value = str(self.attr_id)

      myNode.setAttributeNode(newAttr)

    if self.attr_system != None:

      newAttr = doc.createAttribute('system')

      newAttr.value = str(self.attr_system)

      myNode.setAttributeNode(newAttr)

    if self.attr_scope != None:

      newAttr = doc.createAttribute('scope')

      newAttr.value = str(self.attr_scope)

      myNode.setAttributeNode(newAttr)

    if self.attr_order != None:

      newAttr = doc.createAttribute('order')

      newAttr.value = str(self.attr_order)

      myNode.setAttributeNode(newAttr)

    if self.attr_authSystem != None:

      newAttr = doc.createAttribute('authSystem')

      newAttr.value = str(self.attr_authSystem)

      myNode.setAttributeNode(newAttr)

    if self.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

      myNode.appendChild(self.ReferencesGroup.exportVegX(newEl,doc))

    for childRef in self.allow.all():

      newEl = doc.createElement('allow')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    for childRef in self.deny.all():

      newEl = doc.createElement('deny')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_id':

        self.attr_id = aVal

      elif aName == 'attr_system':

        self.attr_system = aVal

      elif aName == 'attr_scope':

        self.attr_scope = aVal

      elif aName == 'attr_order':

        self.attr_order = aVal

      elif aName == 'attr_authSystem':

        self.attr_authSystem = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'ReferencesGroup':

        newEl = ReferencesGroup().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.ReferencesGroup = newEl

      elif cName == 'allow':

        newEl = AccessRule().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.allow.add(newEl)

      elif cName == 'deny':

        newEl = AccessRule().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.deny.add(newEl)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('id')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('system')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('scope')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('order')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('authSystem')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    if 'ReferencesGroup' not in usedObjectsStack:

      usedObjectsStack.append('ReferencesGroup')

      newEl = doc.createElement('ReferencesGroup')

      newElObj = ReferencesGroup()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'AccessRule' not in usedObjectsStack:

      usedObjectsStack.append('AccessRule')

      newEl = doc.createElement('allow')

      newElObj = AccessRule()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'AccessRule' not in usedObjectsStack:

      usedObjectsStack.append('AccessRule')

      newEl = doc.createElement('deny')

      newElObj = AccessRule()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    a_id = None

    a_system = None

    a_scope = None

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        a_id = aVal

      elif attr == 'system':

        a_system = aVal

      elif attr == 'scope':

        a_scope = aVal

    if a_id != None:

      q = AccessType.objects.filter(attr_id__exact = a_id)

      if a_system != None:

        q = q.filter(attr_system__exact = a_system)

      if a_scope != None:

        q = q.filter(attr_scope__exact = a_scope)

      if len(q) > 0:

        return q[0]

      else:

        return AccessType()

    else:

      return AccessType()

class ReferencesGroup(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  references = models.CharField(max_length=255, null=True, blank=True)

  def exportVegX(self,myNode,doc):

    if self.references != None:

      newEl = doc.createElement('references')

      newElText = doc.createTextNode(str(self.references))

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'references':

        if(len(child.childNodes) > 0):

          cVal = child.childNodes[0].nodeValue

          self.references = cVal

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newEl = doc.createElement('references')

    newElText = doc.createTextNode(str(getRandomString()))

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    return myNode

  def retrieveOrNew(self,node):

    return ReferencesGroup()

class AccessRule(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  def exportVegX(self,myNode,doc):

    for childRef in self.AccessRule_principal_AccessRule_id.all():

      newEl = doc.createElement('principal')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    for childRef in self.AccessRule_permission_AccessRule_id.all():

      newEl = doc.createElement('permission')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      #These are the elements that refer to this one

      if cName == 'principal':

        newEl = AccessRule_principal().retrieveOrNew(child)

        newEl.AccessRule_id = self

        newEl.importVegX(child,info)

      elif cName == 'permission':

        newEl = AccessRule_permission().retrieveOrNew(child)

        newEl.AccessRule_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'AccessRule_principal' not in usedObjectsStack:

      usedObjectsStack.append('AccessRule_principal')

      newEl = doc.createElement('principal')

      childRef = AccessRule_principal()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'AccessRule_permission' not in usedObjectsStack:

      usedObjectsStack.append('AccessRule_permission')

      newEl = doc.createElement('permission')

      childRef = AccessRule_permission()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return AccessRule()

class AccessRule_principal(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  AccessRule_id = models.ForeignKey('AccessRule', related_name='AccessRule_principal_AccessRule_id')

  primitive_type_value = models.CharField(max_length=255, null=True, blank=True)

  def exportVegX(self,myNode,doc):

    if self.primitive_type_value != None:

      newElText = doc.createTextNode(self.primitive_type_value)

      myNode.appendChild(newElText)

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

    if(len(node.childNodes) > 0):

      cVal = node.childNodes[0].nodeValue

      self.primitive_type_value = cVal

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newElText = doc.createTextNode(str(getRandomString()))

    myNode.appendChild(newElText)

    return myNode

  def retrieveOrNew(self,node):

    return AccessRule_principal()

class AccessRule_permission(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  AccessRule_id = models.ForeignKey('AccessRule', related_name='AccessRule_permission_AccessRule_id')

  primitive_type_value = models.CharField(max_length=255, null=True, blank=True)

  def exportVegX(self,myNode,doc):

    if self.primitive_type_value != None:

      newElText = doc.createTextNode(self.primitive_type_value)

      myNode.appendChild(newElText)

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

    if(len(node.childNodes) > 0):

      cVal = node.childNodes[0].nodeValue

      self.primitive_type_value = cVal

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newElText = doc.createTextNode(str(getRandomString()))

    myNode.appendChild(newElText)

    return myNode

  def retrieveOrNew(self,node):

    return AccessRule_permission()

class GeographicCoverage(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  Coverage_id = models.ForeignKey('Coverage', related_name='GeographicCoverage_Coverage_id', null=True, blank=True) #Complex one2Many

  ReferencesGroup = models.ForeignKey('ReferencesGroup', related_name='GeographicCoverage_ReferencesGroup', null=True, blank=True) #Complex one2Many

  boundingCoordinates = models.ForeignKey('boundingCoordinates', related_name='GeographicCoverage_boundingCoordinates', null=True, blank=True) #Complex one2Many

  Map_id = models.ForeignKey('Map', related_name='GeographicCoverage_Map_id', null=True, blank=True) #Complex one2Many

  attr_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)

  attr_system = models.CharField(max_length=255, null=True, blank=True)

  attr_scope = models.CharField(max_length=255, null=True, blank=True, default = 'document')

  geographicDescription = models.CharField(max_length=255, null=True, blank=True)

  def exportVegX(self,myNode,doc):

    if self.attr_id != None:

      newAttr = doc.createAttribute('id')

      newAttr.value = str(self.attr_id)

      myNode.setAttributeNode(newAttr)

    if self.attr_system != None:

      newAttr = doc.createAttribute('system')

      newAttr.value = str(self.attr_system)

      myNode.setAttributeNode(newAttr)

    if self.attr_scope != None:

      newAttr = doc.createAttribute('scope')

      newAttr.value = str(self.attr_scope)

      myNode.setAttributeNode(newAttr)

    if self.geographicDescription != None:

      newEl = doc.createElement('geographicDescription')

      newElText = doc.createTextNode(str(self.geographicDescription))

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

      myNode.appendChild(self.ReferencesGroup.exportVegX(newEl,doc))

    if self.boundingCoordinates != None:

      newEl = doc.createElement('boundingCoordinates')

      myNode.appendChild(self.boundingCoordinates.exportVegX(newEl,doc))

    for childRef in self.datasetGPolygon_GeographicCoverage_id.all():

      newEl = doc.createElement('datasetGPolygon')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_id':

        self.attr_id = aVal

      elif aName == 'attr_system':

        self.attr_system = aVal

      elif aName == 'attr_scope':

        self.attr_scope = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'geographicDescription':

        if(len(child.childNodes) > 0):

          cVal = child.childNodes[0].nodeValue

          self.geographicDescription = cVal

      elif cName == 'ReferencesGroup':

        newEl = ReferencesGroup().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.ReferencesGroup = newEl

      elif cName == 'boundingCoordinates':

        newEl = boundingCoordinates().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.boundingCoordinates = newEl

      #These are the elements that refer to this one

      elif cName == 'datasetGPolygon':

        newEl = datasetGPolygon().retrieveOrNew(child)

        newEl.GeographicCoverage_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('id')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('system')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('scope')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newEl = doc.createElement('geographicDescription')

    newElText = doc.createTextNode(str(getRandomString()))

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    if 'ReferencesGroup' not in usedObjectsStack:

      usedObjectsStack.append('ReferencesGroup')

      newEl = doc.createElement('ReferencesGroup')

      newElObj = ReferencesGroup()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'boundingCoordinates' not in usedObjectsStack:

      usedObjectsStack.append('boundingCoordinates')

      newEl = doc.createElement('boundingCoordinates')

      newElObj = boundingCoordinates()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'datasetGPolygon' not in usedObjectsStack:

      usedObjectsStack.append('datasetGPolygon')

      newEl = doc.createElement('datasetGPolygon')

      childRef = datasetGPolygon()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    a_id = None

    a_system = None

    a_scope = None

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        a_id = aVal

      elif attr == 'system':

        a_system = aVal

      elif attr == 'scope':

        a_scope = aVal

    if a_id != None:

      q = GeographicCoverage.objects.filter(attr_id__exact = a_id)

      if a_system != None:

        q = q.filter(attr_system__exact = a_system)

      if a_scope != None:

        q = q.filter(attr_scope__exact = a_scope)

      if len(q) > 0:

        return q[0]

      else:

        return GeographicCoverage()

    else:

      return GeographicCoverage()

class TemporalCoverage(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  ReferencesGroup = models.ForeignKey('ReferencesGroup', related_name='TemporalCoverage_ReferencesGroup', null=True, blank=True) #Complex one2Many

  rangeOfDates = models.ForeignKey('rangeOfDates', related_name='TemporalCoverage_rangeOfDates', null=True, blank=True) #Complex one2Many

  attr_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)

  def exportVegX(self,myNode,doc):

    if self.attr_id != None:

      newAttr = doc.createAttribute('id')

      newAttr.value = str(self.attr_id)

      myNode.setAttributeNode(newAttr)

    if self.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

      myNode.appendChild(self.ReferencesGroup.exportVegX(newEl,doc))

    if self.rangeOfDates != None:

      newEl = doc.createElement('rangeOfDates')

      myNode.appendChild(self.rangeOfDates.exportVegX(newEl,doc))

    for childRef in self.SingleDateTimeType_TemporalCoverage_id.all():

      newEl = doc.createElement('singleDateTime')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_id':

        self.attr_id = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'ReferencesGroup':

        newEl = ReferencesGroup().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.ReferencesGroup = newEl

      elif cName == 'rangeOfDates':

        newEl = rangeOfDates().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.rangeOfDates = newEl

      #These are the elements that refer to this one

      elif cName == 'singleDateTime':

        newEl = SingleDateTimeType().retrieveOrNew(child)

        newEl.TemporalCoverage_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('id')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    if 'ReferencesGroup' not in usedObjectsStack:

      usedObjectsStack.append('ReferencesGroup')

      newEl = doc.createElement('ReferencesGroup')

      newElObj = ReferencesGroup()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'rangeOfDates' not in usedObjectsStack:

      usedObjectsStack.append('rangeOfDates')

      newEl = doc.createElement('rangeOfDates')

      newElObj = rangeOfDates()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'SingleDateTimeType' not in usedObjectsStack:

      usedObjectsStack.append('SingleDateTimeType')

      newEl = doc.createElement('singleDateTime')

      childRef = SingleDateTimeType()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    id_val = None #ad hoc attr

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        id_val = aVal

    if id_val != None:

      q = TemporalCoverage.objects.filter(attr_id__exact = id_val)

      if len(q) > 0:

        return q[0]

      else:

        return TemporalCoverage()

    else:

      return TemporalCoverage()

  class Meta:

    db_table = u'v_temporalcoverage_uc'

class temporalCoverageLC(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  TemporalCoverage_extend = models.ForeignKey('TemporalCoverage', related_name='temporalCoverageLC_TemporalCoverage_extend') #Complex one2Many

  Coverage_id = models.ForeignKey('Coverage', related_name='temporalCoverageLC_Coverage_id', null=True, blank=True) #Complex one2Many

  attr_system = models.CharField(max_length=255, null=True, blank=True)

  attr_scope = models.CharField(max_length=255, null=True, blank=True, default = 'document')

  def exportVegX(self,myNode,doc):

    if self.attr_system != None:

      newAttr = doc.createAttribute('system')

      newAttr.value = str(self.attr_system)

      myNode.setAttributeNode(newAttr)

    if self.attr_scope != None:

      newAttr = doc.createAttribute('scope')

      newAttr.value = str(self.attr_scope)

      myNode.setAttributeNode(newAttr)

    if self.TemporalCoverage_extend != None:

      myNode = self.TemporalCoverage_extend.exportVegX(myNode,doc)

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    extendedEl = TemporalCoverage().retrieveOrNew(node)

    extendedEl.importVegX(node,info)

    self.TemporalCoverage_extend = extendedEl

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_system':

        self.attr_system = aVal

      elif aName == 'attr_scope':

        self.attr_scope = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('system')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('scope')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    if 'TemporalCoverage' not in usedObjectsStack:

      usedObjectsStack.append('TemporalCoverage')

      newElObj = TemporalCoverage()

      myNode = newElObj.exportDummyVegX(myNode,doc,usedObjectsStack)

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    system_val = None

    scope_val = None

    id_val = None #ad hoc attr

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        id_val = aVal

      if attr == 'system':

        system_val = aVal

      if attr == 'scope':

        scope_val = aVal

    if id_val != None:

      q = temporalCoverageLC.objects.filter(TemporalCoverage_extend__attr_id__exact = id_val)

      if system_val != None:

        q = q.filter(attr_system__exact = system_val)

      if scope_val != None:

        q = q.filter(attr_scope__exact = scope_val)

      if len(q) > 0:

        return q[0]

      else:

        return temporalCoverageLC()

    else:

      return temporalCoverageLC()

class TaxonomicCoverage(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  ReferencesGroup = models.ForeignKey('ReferencesGroup', related_name='TaxonomicCoverage_ReferencesGroup', null=True, blank=True) #Complex one2Many

  taxonomicSystem = models.ForeignKey('taxonomicSystem', related_name='TaxonomicCoverage_taxonomicSystem', null=True, blank=True) #Complex one2Many

  attr_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)

  generalTaxonomicCoverage = models.CharField(max_length=255, null=True, blank=True)

  def exportVegX(self,myNode,doc):

    if self.attr_id != None:

      newAttr = doc.createAttribute('id')

      newAttr.value = str(self.attr_id)

      myNode.setAttributeNode(newAttr)

    if self.generalTaxonomicCoverage != None:

      newEl = doc.createElement('generalTaxonomicCoverage')

      newElText = doc.createTextNode(str(self.generalTaxonomicCoverage))

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

      myNode.appendChild(self.ReferencesGroup.exportVegX(newEl,doc))

    if self.taxonomicSystem != None:

      newEl = doc.createElement('taxonomicSystem')

      myNode.appendChild(self.taxonomicSystem.exportVegX(newEl,doc))

    for childRef in self.TaxonomicClassificationType_TaxonomicCoverage_id.all():

      newEl = doc.createElement('taxonomicClassification')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_id':

        self.attr_id = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'generalTaxonomicCoverage':

        if(len(child.childNodes) > 0):

          cVal = child.childNodes[0].nodeValue

          self.generalTaxonomicCoverage = cVal

      elif cName == 'ReferencesGroup':

        newEl = ReferencesGroup().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.ReferencesGroup = newEl

      elif cName == 'taxonomicSystem':

        newEl = taxonomicSystem().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.taxonomicSystem = newEl

      #These are the elements that refer to this one

      elif cName == 'taxonomicClassification':

        newEl = TaxonomicClassificationType().retrieveOrNew(child)

        newEl.TaxonomicCoverage_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('id')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newEl = doc.createElement('generalTaxonomicCoverage')

    newElText = doc.createTextNode(str(getRandomString()))

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    if 'ReferencesGroup' not in usedObjectsStack:

      usedObjectsStack.append('ReferencesGroup')

      newEl = doc.createElement('ReferencesGroup')

      newElObj = ReferencesGroup()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'taxonomicSystem' not in usedObjectsStack:

      usedObjectsStack.append('taxonomicSystem')

      newEl = doc.createElement('taxonomicSystem')

      newElObj = taxonomicSystem()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'TaxonomicClassificationType' not in usedObjectsStack:

      usedObjectsStack.append('TaxonomicClassificationType')

      newEl = doc.createElement('taxonomicClassification')

      childRef = TaxonomicClassificationType()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    id_val = None #ad hoc attr

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        id_val = aVal

    if id_val != None:

      q = TaxonomicCoverage.objects.filter(attr_id__exact = id_val)

      if len(q) > 0:

        return q[0]

      else:

        return TaxonomicCoverage()

    else:

      return TaxonomicCoverage()

class taxonomicCoverageLC(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  TaxonomicCoverage_extend = models.ForeignKey('TaxonomicCoverage', related_name='taxonomicCoverageLC_TaxonomicCoverage_extend') #Complex one2Many

  Coverage_id = models.ForeignKey('Coverage', related_name='taxonomicCoverageLC_Coverage_id', null=True, blank=True) #Complex one2Many

  attr_system = models.CharField(max_length=255, null=True, blank=True)

  attr_scope = models.CharField(max_length=255, null=True, blank=True, default = 'document')

  def exportVegX(self,myNode,doc):

    if self.attr_system != None:

      newAttr = doc.createAttribute('system')

      newAttr.value = str(self.attr_system)

      myNode.setAttributeNode(newAttr)

    if self.attr_scope != None:

      newAttr = doc.createAttribute('scope')

      newAttr.value = str(self.attr_scope)

      myNode.setAttributeNode(newAttr)

    if self.TaxonomicCoverage_extend != None:

      myNode = self.TaxonomicCoverage_extend.exportVegX(myNode,doc)

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    extendedEl = TaxonomicCoverage().retrieveOrNew(node)

    extendedEl.importVegX(node,info)

    self.TaxonomicCoverage_extend = extendedEl

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_system':

        self.attr_system = aVal

      elif aName == 'attr_scope':

        self.attr_scope = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('system')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('scope')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    if 'TaxonomicCoverage' not in usedObjectsStack:

      usedObjectsStack.append('TaxonomicCoverage')

      newElObj = TaxonomicCoverage()

      myNode = newElObj.exportDummyVegX(myNode,doc,usedObjectsStack)

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    system_val = None

    scope_val = None

    id_val = None #ad hoc attr

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        id_val = aVal

      if attr == 'system':

        system_val = aVal

      if attr == 'scope':

        scope_val = aVal

    if id_val != None:

      q = taxonomicCoverageLC.objects.filter(TaxonomicCoverage_extend__attr_id__exact = id_val)

      if system_val != None:

        q = q.filter(attr_system__exact = system_val)

      if scope_val != None:

        q = q.filter(attr_scope__exact = scope_val)

      if len(q) > 0:

        return q[0]

      else:

        return taxonomicCoverageLC()

    else:

      return taxonomicCoverageLC()

class Coverage(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  ReferencesGroup = models.ForeignKey('ReferencesGroup', related_name='Coverage_ReferencesGroup', null=True, blank=True) #Complex one2Many

  studyAreaDescription_id = models.ForeignKey('studyAreaDescription', related_name='Coverage_studyAreaDescription_id', null=True, blank=True) #Complex one2Many

  attr_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)

  attr_system = models.CharField(max_length=255, null=True, blank=True)

  attr_scope = models.CharField(max_length=255, null=True, blank=True, default = 'document')

  def exportVegX(self,myNode,doc):

    if self.attr_id != None:

      newAttr = doc.createAttribute('id')

      newAttr.value = str(self.attr_id)

      myNode.setAttributeNode(newAttr)

    if self.attr_system != None:

      newAttr = doc.createAttribute('system')

      newAttr.value = str(self.attr_system)

      myNode.setAttributeNode(newAttr)

    if self.attr_scope != None:

      newAttr = doc.createAttribute('scope')

      newAttr.value = str(self.attr_scope)

      myNode.setAttributeNode(newAttr)

    if self.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

      myNode.appendChild(self.ReferencesGroup.exportVegX(newEl,doc))

    for childRef in self.GeographicCoverage_Coverage_id.all():

      newEl = doc.createElement('geographicCoverage')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    for childRef in self.temporalCoverageLC_Coverage_id.all():

      newEl = doc.createElement('temporalCoverage')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    for childRef in self.taxonomicCoverageLC_Coverage_id.all():

      newEl = doc.createElement('taxonomicCoverage')

      myNode.appendChild(childRef.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #attributes

    for attr in node.attributes.keys():

      aName = 'attr_' + attr

      aVal = node.attributes[attr].nodeValue

      if aName == 'attr_id':

        self.attr_id = aVal

      elif aName == 'attr_system':

        self.attr_system = aVal

      elif aName == 'attr_scope':

        self.attr_scope = aVal

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'ReferencesGroup':

        newEl = ReferencesGroup().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.ReferencesGroup = newEl

      #These are the elements that refer to this one

      elif cName == 'geographicCoverage':

        newEl = GeographicCoverage().retrieveOrNew(child)

        newEl.Coverage_id = self

        newEl.importVegX(child,info)

      elif cName == 'temporalCoverage':

        newEl = temporalCoverageLC().retrieveOrNew(child)

        newEl.Coverage_id = self

        newEl.importVegX(child,info)

      elif cName == 'taxonomicCoverage':

        newEl = taxonomicCoverageLC().retrieveOrNew(child)

        newEl.Coverage_id = self

        newEl.importVegX(child,info)

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newAttr = doc.createAttribute('id')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('system')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    newAttr = doc.createAttribute('scope')

    newAttr.value = str(getRandomString())

    myNode.setAttributeNode(newAttr)

    if 'ReferencesGroup' not in usedObjectsStack:

      usedObjectsStack.append('ReferencesGroup')

      newEl = doc.createElement('ReferencesGroup')

      newElObj = ReferencesGroup()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'GeographicCoverage' not in usedObjectsStack:

      usedObjectsStack.append('GeographicCoverage')

      newEl = doc.createElement('geographicCoverage')

      childRef = GeographicCoverage()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'temporalCoverageLC' not in usedObjectsStack:

      usedObjectsStack.append('temporalCoverageLC')

      newEl = doc.createElement('temporalCoverage')

      childRef = temporalCoverageLC()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'taxonomicCoverageLC' not in usedObjectsStack:

      usedObjectsStack.append('taxonomicCoverageLC')

      newEl = doc.createElement('taxonomicCoverage')

      childRef = taxonomicCoverageLC()

      myNode.appendChild(childRef.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    a_id = None

    a_system = None

    a_scope = None

    for attr in node.attributes.keys():

      aVal = node.attributes[attr].nodeValue

      if attr == 'id':

        a_id = aVal

      elif attr == 'system':

        a_system = aVal

      elif attr == 'scope':

        a_scope = aVal

    if a_id != None:

      q = Coverage.objects.filter(attr_id__exact = a_id)

      if a_system != None:

        q = q.filter(attr_system__exact = a_system)

      if a_scope != None:

        q = q.filter(attr_scope__exact = a_scope)

      if len(q) > 0:

        return q[0]

      else:

        return Coverage()

    else:

      return Coverage()

class SingleDateTimeType(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  TemporalCoverage_id = models.ForeignKey('TemporalCoverage', related_name='SingleDateTimeType_TemporalCoverage_id', null=True, blank=True) #Complex one2Many

  alternativeTimeScale = models.ForeignKey('alternativeTimeScale', related_name='SingleDateTimeType_alternativeTimeScale', null=True, blank=True) #Complex one2Many

  calendarDate = models.DateField(null=True, blank=True)

  time = models.TimeField(null=True, blank=True)

  def exportVegX(self,myNode,doc):

    if self.calendarDate != None:

      newEl = doc.createElement('calendarDate')

      newElText = doc.createTextNode(str(self.calendarDate))

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.time != None:

      newEl = doc.createElement('time')

      newElText = doc.createTextNode(str(self.time))

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.alternativeTimeScale != None:

      newEl = doc.createElement('alternativeTimeScale')

      myNode.appendChild(self.alternativeTimeScale.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'calendarDate':

        if(len(child.childNodes) > 0):

          cVal = child.childNodes[0].nodeValue

          self.calendarDate = cVal

      elif cName == 'time':

        if(len(child.childNodes) > 0):

          cVal = child.childNodes[0].nodeValue

          self.time = cVal

      elif cName == 'alternativeTimeScale':

        newEl = alternativeTimeScale().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.alternativeTimeScale = newEl

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    newEl = doc.createElement('calendarDate')

    newElText = doc.createTextNode(str(getRandomDate()))

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    newEl = doc.createElement('time')

    newElText = doc.createTextNode(str(getRandomTime()))

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    if 'alternativeTimeScale' not in usedObjectsStack:

      usedObjectsStack.append('alternativeTimeScale')

      newEl = doc.createElement('alternativeTimeScale')

      newElObj = alternativeTimeScale()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return SingleDateTimeType()

class rangeOfDates(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  beginDate = models.ForeignKey('SingleDateTimeType', related_name='rangeOfDates_beginDate', null=True, blank=True) #Complex one2Many

  endDate = models.ForeignKey('SingleDateTimeType', related_name='rangeOfDates_endDate', null=True, blank=True) #Complex one2Many

  def exportVegX(self,myNode,doc):

    if self.beginDate != None:

      newEl = doc.createElement('beginDate')

      myNode.appendChild(self.beginDate.exportVegX(newEl,doc))

    if self.endDate != None:

      newEl = doc.createElement('endDate')

      myNode.appendChild(self.endDate.exportVegX(newEl,doc))

    return myNode

  def importVegX(self,node,info):

    self.entryInfo = info

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'beginDate':

        newEl = SingleDateTimeType().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.beginDate = newEl

      elif cName == 'endDate':

        newEl = SingleDateTimeType().retrieveOrNew(child)

        newEl.importVegX(child,info)

        self.endDate = newEl

    self.save()

  def exportDummyVegX(self,myNode,doc,usedObjectsStack):

    if 'SingleDateTimeType' not in usedObjectsStack:

      usedObjectsStack.append('SingleDateTimeType')

      newEl = doc.createElement('beginDate')

      newElObj = SingleDateTimeType()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    if 'SingleDateTimeType' not in usedObjectsStack:

      usedObjectsStack.append('SingleDateTimeType')

      newEl = doc.createElement('endDate')

      newElObj = SingleDateTimeType()

      myNode.appendChild(newElObj.exportDummyVegX(newEl,doc,usedObjectsStack))

      usedObjectsStack.pop()

    return myNode

  def retrieveOrNew(self,node):

    return rangeOfDates()

class CitationType(models.Model):

  entryInfo = models.ForeignKey('EntryInfo')

  alternativeTimeScale_id = models.ForeignKey('alternativeTimeScale', related_name='CitationType_alternativeTimeScale_id', null=True, blank=True) #Complex one2Many

  taxonomicSystem_id = models.ForeignKey('taxonomicSystem', related_name='CitationType_taxonomicSystem_id', null=True, blank=True) #Complex one2Many

  ReferencesGroup = models.ForeignKey('ReferencesGroup', related_name='CitationType_ReferencesGroup', null=True, blank=True) #Complex one2Many

  ResourceGroup = models.ForeignKey('ResourceGroup', related_name='CitationType_ResourceGroup', null=True, blank=True) #Complex one2Many

  access = models.ForeignKey('AccessType', related_name='CitationType_access', null=True, blank=True) #Complex one2Many

  article = models.ForeignKey('Article', related_name='CitationType_article', null=True, blank=True) #Complex one2Many

  book = models.ForeignKey('Book', related_name='CitationType_book', null=True, blank=True) #Complex one2Many

  chapter = models.ForeignKey('Chapter', related_name='CitationType_chapter', null=True, blank=True) #Complex one2Many

  editedBook = models.ForeignKey('Book', related_name='CitationType_editedBook', null=True, blank=True) #Complex one2Many

  manuscript = models.ForeignKey('Manuscript', related_name='CitationType_manuscript', null=True, blank=True) #Complex one2Many

  report = models.ForeignKey('Report', related_name='CitationType_report', null=True, blank=True) #Complex one2Many

  thesis = models.ForeignKey('Thesis', related_name='CitationType_thesis', null=True, blank=True) #Complex one2Many

  conferenceProceedings = models.ForeignKey('ConferenceProceedings', related_name='CitationType_conferenceProceedings', null=True, blank=True) #Complex one2Many

  personalCommunication = models.ForeignKey('PersonalCommunication', related_name='CitationType_personalCommunication', null=True, blank=True) #Complex one2Many

  map = models.ForeignKey('Map', related_name='CitationType_map', null=True, blank=True) #Complex one2Many

  generic = models.ForeignKey('Generic', related_name='CitationType_generic', null=True, blank=True) #Complex one2Many

  audioVisual = models.ForeignKey('AudioVisual', related_name='CitationType_audioVisual', null=True, blank=True) #Complex one2Many

  presentation = models.ForeignKey('Presentation', related_name='CitationType_presentation', null=True, blank=True) #Complex one2Many

  descriptor_id = models.ForeignKey('descriptor', related_name='CitationType_descriptor_id', null=True, blank=True) #Complex one2Many

  studyAreaDescription_id = models.ForeignKey('studyAreaDescription', related_name='CitationType_studyAreaDescription_id', null=True, blank=True) #Complex one2Many

  designDescription_id = models.ForeignKey('designDescription', related_name='CitationType_designDescription_id', null=True, blank=True) #Complex one2Many

  literature_id = models.ForeignKey('literature', related_name='CitationType_literature_id', null=True, blank=True) #Complex one2Many

  attr_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)

  attr_system = models.CharField(max_length=255, null=True, blank=True)

  attr_scope = models.CharField(max_length=255, null=True, blank=True, default = 'document')

  def exportVegX(self,myNode,doc):

    if self.attr_id != None:

      newAttr = doc.createAttribute('id')

      newAttr.value = str(self.attr_id)

      myNode.setAttributeNode(newAttr)

    if self.attr_system != None:

      newAttr = doc.createAttribute('system')

      newAttr.value = str(self.attr_system)

      myNode.setAttributeNode(newAttr)

    if self.attr_scope != None:

      newAttr = doc.createAttribute('scope')

      newAttr.value = str(self.attr_scope)

      myNode.setAttributeNode(newAttr)

    if self.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

      myNode.appendChild(self.ReferencesGroup.exportVegX(newEl,doc))

    if self.ResourceGroup != None:

      newEl = doc.createElement('ResourceGroup')

      myNode.appendChild(self.ResourceGroup.exportVegX(newEl,doc))

    if self.access != None:

      newEl = doc.createElement('access')

      myNode.appendChild(self.access.exportVegX(newEl,doc))

    if self.article != None:

      newEl = doc.createElement('article')

      myNode.appendChild(self.article.exportVegX(newEl,doc))

    if self.book != None:

      newEl = doc.createElement('book')

      myNode.appendChild(self.book.exportVegX(newEl,doc))

    if self.chapter != None:

      newEl = doc.createElement('chapter')

      myNode.appendChild(self.chapter.exportVegX(newEl,doc))

    if self.editedBook != None:

      newEl = doc.createElement('editedBook')

      myNode.appendChild(self.editedBook.exportVegX(newEl,doc))

    if self.manuscript != None:

      newEl = doc.createElement('manuscript')

      myNode.appendChild(self.manuscript.exportVegX(newEl,doc))

    if self.report != None:

      newEl = doc.createElement('report')

      myNode.appendChild(self.report.exportVegX(newEl,doc))

    if self.thesis != None:

      newEl = doc.createElement('thesis')

      myNode.appendChild(self.thesis.exportVegX(newEl,doc))

    if self.conferenceProceedings != None:

      newEl = doc.createElement('conferenceProceedings')

      myNode.appendChild(self.conferenceProceedings.exportVegX(newEl,doc))

    if self.personalCommunication != None:

      newEl = doc.createElement('personalCommunication')

      myNode.appendChild(self.personalCommunication.exportVegX(newEl,doc))

    if self.map != None:

      newEl = doc.createElement('map')

      myNode.appendChild(self.map.exportVegX(newEl,doc))

    if self.generic != None:

      newEl = doc.createElement('generic')

      myNode.appendChild(self.generic.exportVegX(newEl,doc))

    if self.audioVisual != None:

      newEl = doc.createElement('audioVisual')

      myNode.appendChild(self.audioVisual.exportVegX(newEl,doc))