#!/usr/bin/env python

from django.core.management import execute_manager

try:

    import settings # Assumed to be in the same directory.

except ImportError:

    import sys

    sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)

    sys.exit(1)

if __name__ == "__main__":

    execute_manager(settings)

-------------------------------------------------------------------------------------------------------

If you encounter the following error:

"/usr/lib/python2.5/site-packages/django/db/backends/postgresql_psycopg2/base.py",

line 44, in execute

    return self.cursor.execute(query, args)

django.db.utils.DatabaseError: value too long for type character varying(50)

The solution is:

In the database (postgresql) the name column in the auth_permission table

needs to have a character_varying width of greater than 50.

alter table auth_permission alter column name type character varying(255);

From:

http://code.google.com/p/evennia/issues/detail?id=84

-------------------------------------------------------------------------------------------------------

# Create your views here.

"""

This file demonstrates two different styles of tests (one doctest and one

unittest). These will both pass when you run "manage.py test".

Replace these with more appropriate tests for your application.

"""

from django.test import TestCase

class SimpleTest(TestCase):

    def test_basic_addition(self):

        """

        Tests that 1 + 1 always equals 2.

        """

        self.failUnlessEqual(1 + 1, 2)

__test__ = {"doctest": """

Another way to test that 1 + 1 is equal to 2.

>>> 1 + 1 == 2

True

"""}

#There are 223 defined entities.

import string

import xml.dom.minidom

from random import choice

from django.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 eml_access(models.Model):

  access = models.ForeignKey('AccessType', unique=True,related_name='eml_access_access', null=True, blank=True)

  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):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'access':

        newEl = AccessType()

        newEl.importVegX(child)

        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

class AccessType(models.Model):

  ReferencesGroup = models.ForeignKey('ReferencesGroup', unique=True,related_name='AccessType_ReferencesGroup', null=True, blank=True)

  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)

  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):

    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()

        newEl.importVegX(child)

        self.ReferencesGroup = newEl

      elif cName == 'allow':

        newEl = AccessRule()

        newEl.importVegX(child)

        self.allow.add(newEl)

      elif cName == 'deny':

        newEl = AccessRule()

        newEl.importVegX(child)

        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

class ReferencesGroup(models.Model):

  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):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'references':

        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

class AccessRule(models.Model):

  id = models.AutoField(primary_key=True)

  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):

    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()

        newEl.AccessRule_id = self

        newEl.importVegX(child)

      elif cName == 'permission':

        newEl = AccessRule_permission()

        newEl.AccessRule_id = self

        newEl.importVegX(child)

    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

class AccessRule_principal(models.Model):

  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):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

    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

class AccessRule_permission(models.Model):

  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):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

    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

class GeographicCoverage(models.Model):

  ReferencesGroup = models.ForeignKey('ReferencesGroup', unique=True,related_name='GeographicCoverage_ReferencesGroup', null=True, blank=True)

  boundingCoordinates = models.ForeignKey('boundingCoordinates', unique=True,related_name='GeographicCoverage_boundingCoordinates', null=True, blank=True)

  datasetGPolygon = models.ManyToManyField('datasetGPolygon',related_name='GeographicCoverage_datasetGPolygon')

  attr_id = models.CharField(max_length=255, null=True, blank=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.all():

      newEl = doc.createElement('datasetGPolygon')

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

    return myNode

  def importVegX(self,node):

    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':

        cVal = child.childNodes[0].nodeValue

        self.geographicDescription = cVal

      elif cName == 'ReferencesGroup':

        newEl = ReferencesGroup()

        newEl.importVegX(child)

        self.ReferencesGroup = newEl

      elif cName == 'boundingCoordinates':

        newEl = boundingCoordinates()

        newEl.importVegX(child)

        self.boundingCoordinates = newEl

      elif cName == 'datasetGPolygon':

        newEl = datasetGPolygon()

        newEl.importVegX(child)

        self.datasetGPolygon.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)

    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')

      newElObj = datasetGPolygon()

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

      usedObjectsStack.pop()

    return myNode

class TemporalCoverage(models.Model):

  ReferencesGroup = models.ForeignKey('ReferencesGroup', unique=True,related_name='TemporalCoverage_ReferencesGroup', null=True, blank=True)

  singleDateTime = models.ManyToManyField('SingleDateTimeType',related_name='TemporalCoverage_singleDateTime')

  rangeOfDates = models.ForeignKey('rangeOfDates', unique=True,related_name='TemporalCoverage_rangeOfDates', null=True, blank=True)

  attr_id = 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.ReferencesGroup != None:

      newEl = doc.createElement('ReferencesGroup')

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

    for childRef in self.singleDateTime.all():

      newEl = doc.createElement('singleDateTime')

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

    if self.rangeOfDates != None:

      newEl = doc.createElement('rangeOfDates')

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

    return myNode

  def importVegX(self,node):

    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()

        newEl.importVegX(child)

        self.ReferencesGroup = newEl

      elif cName == 'singleDateTime':

        newEl = SingleDateTimeType()

        newEl.importVegX(child)

        self.singleDateTime.add(newEl)

      elif cName == 'rangeOfDates':

        newEl = rangeOfDates()

        newEl.importVegX(child)

        self.rangeOfDates = newEl

    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 'SingleDateTimeType' not in usedObjectsStack:

      usedObjectsStack.append('SingleDateTimeType')

      newEl = doc.createElement('singleDateTime')

      newElObj = SingleDateTimeType()

      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()

    return myNode

class temporalCoverage(models.Model):

  TemporalCoverage_extend = models.ForeignKey('TemporalCoverage', unique=True,related_name='temporalCoverage_TemporalCoverage_extend')

  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):

    extendedEl = TemporalCoverage()

    extendedEl.importVegX(node)

    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

class TaxonomicCoverage(models.Model):

  ReferencesGroup = models.ForeignKey('ReferencesGroup', unique=True,related_name='TaxonomicCoverage_ReferencesGroup', null=True, blank=True)

  taxonomicSystem = models.ForeignKey('taxonomicSystem', unique=True,related_name='TaxonomicCoverage_taxonomicSystem', null=True, blank=True)

  taxonomicClassification = models.ManyToManyField('TaxonomicClassificationType',related_name='TaxonomicCoverage_taxonomicClassification',db_table = 'v_TaxonomicCoverage_TaxonomicClassificationType_taxonomi')

  attr_id = models.CharField(max_length=255, null=True, blank=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.taxonomicClassification.all():

      newEl = doc.createElement('taxonomicClassification')

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

    return myNode

  def importVegX(self,node):

    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':

        cVal = child.childNodes[0].nodeValue

        self.generalTaxonomicCoverage = cVal

      elif cName == 'ReferencesGroup':

        newEl = ReferencesGroup()

        newEl.importVegX(child)

        self.ReferencesGroup = newEl

      elif cName == 'taxonomicSystem':

        newEl = taxonomicSystem()

        newEl.importVegX(child)

        self.taxonomicSystem = newEl

      elif cName == 'taxonomicClassification':

        newEl = TaxonomicClassificationType()

        newEl.importVegX(child)

        self.taxonomicClassification.add(newEl)

    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')

      newElObj = TaxonomicClassificationType()

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

      usedObjectsStack.pop()

    return myNode

class taxonomicCoverage(models.Model):

  TaxonomicCoverage_extend = models.ForeignKey('TaxonomicCoverage', unique=True,related_name='taxonomicCoverage_TaxonomicCoverage_extend')

  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):

    extendedEl = TaxonomicCoverage()

    extendedEl.importVegX(node)

    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

class Coverage(models.Model):

  ReferencesGroup = models.ForeignKey('ReferencesGroup', unique=True,related_name='Coverage_ReferencesGroup', null=True, blank=True)

  geographicCoverage = models.ManyToManyField('GeographicCoverage',related_name='Coverage_geographicCoverage')

  temporalCoverage = models.ManyToManyField('temporalCoverage',related_name='Coverage_temporalCoverage')

  taxonomicCoverage = models.ManyToManyField('taxonomicCoverage',related_name='Coverage_taxonomicCoverage')

  attr_id = models.CharField(max_length=255, null=True, blank=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.all():

      newEl = doc.createElement('geographicCoverage')

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

    for childRef in self.temporalCoverage.all():

      newEl = doc.createElement('temporalCoverage')

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

    for childRef in self.taxonomicCoverage.all():

      newEl = doc.createElement('taxonomicCoverage')

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

    return myNode

  def importVegX(self,node):

    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()

        newEl.importVegX(child)

        self.ReferencesGroup = newEl

      elif cName == 'geographicCoverage':

        newEl = GeographicCoverage()

        newEl.importVegX(child)

        self.geographicCoverage.add(newEl)

      elif cName == 'temporalCoverage':

        newEl = temporalCoverage()

        newEl.importVegX(child)

        self.temporalCoverage.add(newEl)

      elif cName == 'taxonomicCoverage':

        newEl = taxonomicCoverage()

        newEl.importVegX(child)

        self.taxonomicCoverage.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)

    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')

      newElObj = GeographicCoverage()

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

      usedObjectsStack.pop()

    if 'temporalCoverage' not in usedObjectsStack:

      usedObjectsStack.append('temporalCoverage')

      newEl = doc.createElement('temporalCoverage')

      newElObj = temporalCoverage()

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

      usedObjectsStack.pop()

    if 'taxonomicCoverage' not in usedObjectsStack:

      usedObjectsStack.append('taxonomicCoverage')

      newEl = doc.createElement('taxonomicCoverage')

      newElObj = taxonomicCoverage()

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

      usedObjectsStack.pop()

    return myNode

class SingleDateTimeType(models.Model):

  alternativeTimeScale = models.ForeignKey('alternativeTimeScale', unique=True,related_name='SingleDateTimeType_alternativeTimeScale', null=True, blank=True)

  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):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'calendarDate':

        cVal = child.childNodes[0].nodeValue

        self.calendarDate = cVal

      elif cName == 'time':

        cVal = child.childNodes[0].nodeValue

        self.time = cVal

      elif cName == 'alternativeTimeScale':

        newEl = alternativeTimeScale()

        newEl.importVegX(child)

        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

class rangeOfDates(models.Model):

  beginDate = models.ForeignKey('SingleDateTimeType', unique=True,related_name='rangeOfDates_beginDate', null=True, blank=True)

  endDate = models.ForeignKey('SingleDateTimeType', unique=True,related_name='rangeOfDates_endDate', null=True, blank=True)

  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):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'beginDate':

        newEl = SingleDateTimeType()

        newEl.importVegX(child)

        self.beginDate = newEl

      elif cName == 'endDate':

        newEl = SingleDateTimeType()

        newEl.importVegX(child)

        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

class CitationType(models.Model):

  ReferencesGroup = models.ForeignKey('ReferencesGroup', unique=True,related_name='CitationType_ReferencesGroup', null=True, blank=True)

  ResourceGroup = models.ForeignKey('ResourceGroup', unique=True,related_name='CitationType_ResourceGroup', null=True, blank=True)

  access = models.ForeignKey('AccessType', unique=True,related_name='CitationType_access', null=True, blank=True)

  article = models.ForeignKey('Article', unique=True,related_name='CitationType_article', null=True, blank=True)

  book = models.ForeignKey('Book', unique=True,related_name='CitationType_book', null=True, blank=True)

  chapter = models.ForeignKey('Chapter', unique=True,related_name='CitationType_chapter', null=True, blank=True)

  editedBook = models.ForeignKey('Book', unique=True,related_name='CitationType_editedBook', null=True, blank=True)

  manuscript = models.ForeignKey('Manuscript', unique=True,related_name='CitationType_manuscript', null=True, blank=True)

  report = models.ForeignKey('Report', unique=True,related_name='CitationType_report', null=True, blank=True)

  thesis = models.ForeignKey('Thesis', unique=True,related_name='CitationType_thesis', null=True, blank=True)

  conferenceProceedings = models.ForeignKey('ConferenceProceedings', unique=True,related_name='CitationType_conferenceProceedings', null=True, blank=True)

  personalCommunication = models.ForeignKey('PersonalCommunication', unique=True,related_name='CitationType_personalCommunication', null=True, blank=True)

  map = models.ForeignKey('Map', unique=True,related_name='CitationType_map', null=True, blank=True)

  generic = models.ForeignKey('Generic', unique=True,related_name='CitationType_generic', null=True, blank=True)

  audioVisual = models.ForeignKey('AudioVisual', unique=True,related_name='CitationType_audioVisual', null=True, blank=True)

  presentation = models.ForeignKey('Presentation', unique=True,related_name='CitationType_presentation', null=True, blank=True)

  attr_id = models.CharField(max_length=255, null=True, blank=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))

    if self.presentation != None:

      newEl = doc.createElement('presentation')

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

    return myNode

  def importVegX(self,node):

    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()

        newEl.importVegX(child)

        self.ReferencesGroup = newEl

      elif cName == 'ResourceGroup':

        newEl = ResourceGroup()

        newEl.importVegX(child)

        self.ResourceGroup = newEl

      elif cName == 'access':

        newEl = AccessType()

        newEl.importVegX(child)

        self.access = newEl

      elif cName == 'article':

        newEl = Article()

        newEl.importVegX(child)

        self.article = newEl

      elif cName == 'book':

        newEl = Book()

        newEl.importVegX(child)

        self.book = newEl

      elif cName == 'chapter':

        newEl = Chapter()

        newEl.importVegX(child)

        self.chapter = newEl

      elif cName == 'editedBook':

        newEl = Book()

        newEl.importVegX(child)

        self.editedBook = newEl

      elif cName == 'manuscript':

        newEl = Manuscript()

        newEl.importVegX(child)

        self.manuscript = newEl

      elif cName == 'report':

        newEl = Report()

        newEl.importVegX(child)

        self.report = newEl

      elif cName == 'thesis':

        newEl = Thesis()

        newEl.importVegX(child)

        self.thesis = newEl

      elif cName == 'conferenceProceedings':

        newEl = ConferenceProceedings()

        newEl.importVegX(child)

        self.conferenceProceedings = newEl

      elif cName == 'personalCommunication':

        newEl = PersonalCommunication()

        newEl.importVegX(child)

        self.personalCommunication = newEl

      elif cName == 'map':

        newEl = Map()

        newEl.importVegX(child)

        self.map = newEl

      elif cName == 'generic':

        newEl = Generic()

        newEl.importVegX(child)

        self.generic = newEl

      elif cName == 'audioVisual':

        newEl = AudioVisual()

        newEl.importVegX(child)

        self.audioVisual = newEl

      elif cName == 'presentation':

        newEl = Presentation()

        newEl.importVegX(child)

        self.presentation = 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)

    if 'ReferencesGroup' not in usedObjectsStack:

      usedObjectsStack.append('ReferencesGroup')

      newEl = doc.createElement('ReferencesGroup')

      newElObj = ReferencesGroup()

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

      usedObjectsStack.pop()

    if 'ResourceGroup' not in usedObjectsStack:

      usedObjectsStack.append('ResourceGroup')

      newEl = doc.createElement('ResourceGroup')

      newElObj = ResourceGroup()

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

      usedObjectsStack.pop()

    if 'AccessType' not in usedObjectsStack:

      usedObjectsStack.append('AccessType')

      newEl = doc.createElement('access')

      newElObj = AccessType()

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

      usedObjectsStack.pop()

    if 'Article' not in usedObjectsStack:

      usedObjectsStack.append('Article')

      newEl = doc.createElement('article')

      newElObj = Article()

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

      usedObjectsStack.pop()

    if 'Book' not in usedObjectsStack:

      usedObjectsStack.append('Book')

      newEl = doc.createElement('book')

      newElObj = Book()

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

      usedObjectsStack.pop()

    if 'Chapter' not in usedObjectsStack:

      usedObjectsStack.append('Chapter')

      newEl = doc.createElement('chapter')

      newElObj = Chapter()

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

      usedObjectsStack.pop()

    if 'Book' not in usedObjectsStack:

      usedObjectsStack.append('Book')

      newEl = doc.createElement('editedBook')

      newElObj = Book()

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

      usedObjectsStack.pop()

    if 'Manuscript' not in usedObjectsStack:

      usedObjectsStack.append('Manuscript')

      newEl = doc.createElement('manuscript')

      newElObj = Manuscript()

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

      usedObjectsStack.pop()

    if 'Report' not in usedObjectsStack:

      usedObjectsStack.append('Report')

      newEl = doc.createElement('report')

      newElObj = Report()

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

      usedObjectsStack.pop()

    if 'Thesis' not in usedObjectsStack:

      usedObjectsStack.append('Thesis')

      newEl = doc.createElement('thesis')

      newElObj = Thesis()

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

      usedObjectsStack.pop()

    if 'ConferenceProceedings' not in usedObjectsStack:

      usedObjectsStack.append('ConferenceProceedings')

      newEl = doc.createElement('conferenceProceedings')

      newElObj = ConferenceProceedings()

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

      usedObjectsStack.pop()

    if 'PersonalCommunication' not in usedObjectsStack:

      usedObjectsStack.append('PersonalCommunication')

      newEl = doc.createElement('personalCommunication')

      newElObj = PersonalCommunication()

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

      usedObjectsStack.pop()

    if 'Map' not in usedObjectsStack:

      usedObjectsStack.append('Map')

      newEl = doc.createElement('map')

      newElObj = Map()

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

      usedObjectsStack.pop()

    if 'Generic' not in usedObjectsStack:

      usedObjectsStack.append('Generic')

      newEl = doc.createElement('generic')

      newElObj = Generic()

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

      usedObjectsStack.pop()

    if 'AudioVisual' not in usedObjectsStack:

      usedObjectsStack.append('AudioVisual')

      newEl = doc.createElement('audioVisual')

      newElObj = AudioVisual()

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

      usedObjectsStack.pop()

    if 'Presentation' not in usedObjectsStack:

      usedObjectsStack.append('Presentation')

      newEl = doc.createElement('presentation')

      newElObj = Presentation()

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

      usedObjectsStack.pop()

    return myNode

class alternativeTimeScale(models.Model):

  timeScaleCitation = models.ManyToManyField('CitationType',related_name='alternativeTimeScale_timeScaleCitation')

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

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

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

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

  def exportVegX(self,myNode,doc):

    if self.timeScaleName != None:

      newEl = doc.createElement('timeScaleName')

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

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.timeScaleAgeEstimate != None:

      newEl = doc.createElement('timeScaleAgeEstimate')

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

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.timeScaleAgeUncertainty != None:

      newEl = doc.createElement('timeScaleAgeUncertainty')

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

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    if self.timeScaleAgeExplanation != None:

      newEl = doc.createElement('timeScaleAgeExplanation')

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

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)

    for childRef in self.timeScaleCitation.all():

      newEl = doc.createElement('timeScaleCitation')

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

    return myNode

  def importVegX(self,node):

    self.save()

    #members & relationships

    for child in node.childNodes:

      cName = child.nodeName

      if cName == 'timeScaleName':

        cVal = child.childNodes[0].nodeValue

        self.timeScaleName = cVal

      elif cName == 'timeScaleAgeEstimate':

        cVal = child.childNodes[0].nodeValue

        self.timeScaleAgeEstimate = cVal

      elif cName == 'timeScaleAgeUncertainty':

        cVal = child.childNodes[0].nodeValue

        self.timeScaleAgeUncertainty = cVal

      elif cName == 'timeScaleAgeExplanation':

        cVal = child.childNodes[0].nodeValue

        self.timeScaleAgeExplanation = cVal

      elif cName == 'timeScaleCitation':

        newEl = CitationType()

        newEl.importVegX(child)

        self.timeScaleCitation.add(newEl)

    self.save()

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

    newEl = doc.createElement('timeScaleName')

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

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    newEl = doc.createElement('timeScaleAgeEstimate')

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

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    newEl = doc.createElement('timeScaleAgeUncertainty')

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

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    newEl = doc.createElement('timeScaleAgeExplanation')

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

    newEl.appendChild(newElText)

    myNode.appendChild(newEl)

    if 'CitationType' not in usedObjectsStack:

      usedObjectsStack.append('CitationType')

      newEl = doc.createElement('timeScaleCitation')

      newElObj = CitationType()

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

      usedObjectsStack.pop()

    return myNode

class boundingAltitudes(models.Model):

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

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

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

  def exportVegX(self,myNode,doc):

    if self.altitudeMinimum != None:

      newEl = doc.createElement('altitudeMinimum')

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

      newEl.appendChild(newElText)

      myNode.appendChild(newEl)