source: mauRepo/MolesManager/trunk/src/libs/migration/processor/commons.py @ 8258

'''
Created on 15 Nov 2011

@author: mnagni
'''
from ea_model.moles3_4.utilities.mo_responsiblepartyinfo import MO_ResponsiblePartyInfo
from ea_model.iso_19115_2006_metadata_corrigendum.reference_system_information.md_identifier import MD_Identifier
from httplib import HTTPConnection
from xml.etree.ElementTree import XML, tostring
import time, datetime
from ea_model.upcomingiso.ci_organisation import CI_Organisation
from ea_model.upcomingiso.ci_party import CI_Party
from ea_model.upcomingiso.ci_individual import CI_Individual
from libs.migration.exception.exceptions import NoDataLineage
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_citation import CI_Citation
from ea_model.iso_19115_2006_metadata_corrigendum.data_quality_information.dq_element import DQ_Element
from ea_model.iso_19115_2006_metadata_corrigendum.data_quality_information.dq_conformanceresult import DQ_ConformanceResult
from hashlib import md5
from xml.sax.saxutils import unescape, escape
import html5lib
from html5lib import treebuilders
from ea_model.ceda_metadatamodel.ceda_result.ceda_result import CEDA_Result
from ea_model.moles3_4.result.mo_onlineresource import MO_OnlineResource
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.url import URL
from ea_model.iso_19115_2006_metadata_corrigendum.extent_information.ex_geographicboundingbox import EX_GeographicBoundingBox
from ea_model.ceda_metadatamodel.ceda_computation.ceda_processing import CEDA_Processing
from ea_model.ceda_metadatamodel.ceda_acquisition.ceda_instrument import CEDA_Instrument
from ea_model.ceda_metadatamodel.ceda_observationprocess.ceda_compositeprocess import CEDA_CompositeProcess
from ea_model.ceda_metadatamodel.ceda_acquisition.ceda_acquisition import CEDA_Acquisition
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_date import CI_Date
from ea_model.iso_19103_2005_schema_language.basic_types.primitive.date_and_time.datetime import DateTime
from ea_model.iso_19103_2005_schema_language.basic_types.primitive.date_and_time.date import Date
from ea_model.iso_19108_2006_temporal_schema.temporal_reference_system.tm_position import TM_Position
from ea_model.iso_19108_2006_temporal_schema.temporal_objects.tm_instant import TM_Instant
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_contact import CI_Contact
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_address import CI_Address
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_onlineresource import CI_OnlineResource
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_telephone import CI_Telephone
from ea_model.iso_19108_2006_temporal_schema.temporal_objects.tm_period import TM_Period
from ea_model.iso_19115_2006_metadata_corrigendum.constraint_information.md_constraints import MD_Constraints
from ea_model.iso_19115_2006_metadata_corrigendum.constraint_information.md_legalconstraints import MD_LegalConstraints
from ea_model.ceda_metadatamodel.ceda_project.ceda_project import CEDA_Project
from ea_model.iso_19115_2006_metadata_corrigendum.metadata_entity_set_information.md_metadata import MD_Metadata
from ea_model.ceda_metadatamodel.ceda_utilities.ceda_review import CEDA_Review
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_responsibleparty import CI_ResponsibleParty
from ea_model.iso_19115_2006_metadata_corrigendum.maintenance_information.md_maintenancefrequencycode import MD_MaintenanceFrequencyCode

base = '/exist/rest/atoms'

DS_pUBLISHED = 'published'
DS_WORKING = 'working'
DS_PUBLISHED = 'Published'
docStatus = (DS_pUBLISHED, DS_WORKING, DS_PUBLISHED)

DT_DEPLOYMENTS = 'deployments'
DT_DATA_ENTITIES = 'data_entities'
DT_DEPLOYMENT_DATA = 'deployment_data'
DT_DATA_GRANULES = 'data_granules'
docTypes = (DT_DEPLOYMENTS, DT_DATA_ENTITIES, DT_DEPLOYMENT_DATA, DT_DATA_GRANULES)

DO_BADC = 'badc.nerc.ac.uk'
DO_NEODC = 'neodc.nerc.ac.uk'
DO_UKSSDC = 'ukssdc.ac.uk'

CEDA = 'Centre for Environmental Data Archive'
docOwners = (DO_BADC, DO_NEODC, DO_UKSSDC)

atomNS = "{http://www.w3.org/2005/Atom}"
existNS = "{http://exist.sourceforge.net/NS/exist}"
molesNS = "{http://ndg.nerc.ac.uk/schema/moles2beta}"
htmlNS = "{http://www.w3.org/1999/xhtml}"
georssNS="{http://www.georss.org/georss/10}"
gmlNS="{http://www.opengis.net/gml}"
date_format = '%Y-%m-%d'
datetime_format = date_format + 'T%H:%M:%SZ'
ihost = 'bora.badc.rl.ac.uk'
iport = '8080'

linkMarkers = ['Deployment', 'DOWNLOAD', 'DOCUMENTATION', 'ACCESS', 'LOGO', 'ACTIVITY', 'DPT', 'OBS']

#MD_Identifier codes
MD_CODE_MOLES2_CITATION = 'ceda_moles2_citation'

htmlParser = html5lib.HTMLParser(tree=treebuilders.getTreeBuilder("etree"), namespaceHTMLElements=False)

def calculateHash(text):
    """
        Returns an md5 hexadecimal representation of the given text
        @param text: the string to encode
        @return: the hexadecimal md5 value of the given text 
    """
    encoder = md5()
    encoder.update(text)
    return encoder.hexdigest()

def buildExistDocPath(docStatus, docType, docOwner, docName):
    '''
        @param docStatus: one value from commons.docStatus
        @param docType: one value from commons.docTypes 
        @param docOwner: one value from commons.docOwners
        @param docName: one value from commons.docOwners        
    '''        
    return '%s/%s' % (buildExistOwnerPath(docStatus, docType, docOwner), docName)

def buildExistOwnerPath(docStatus, docType, docOwner):
    '''
        @param docStatus: one value from commons.docStatus
        @param docType: one value from commons.docCollections 
        @param docOwner: one value from commons.docOwners
    '''        
    return '%s/%s' % (buildExistTypePath(docStatus, docType), docOwner)

def buildExistTypePath(docStatus, docType):
    '''
        @param docStatus: one value from commons.docStatus
        @param docType: one value from commons.docCollections 
    '''        
    return '%s/%s' % (buildExistStatusPath(docStatus), docType)

def buildExistStatusPath(docStatus):
    '''
        @param docStatus: one value from commons.docStatus 
    '''        
    return '/exist/rest/atoms/%s' % (docStatus)

def getAtomDocumentByMO(migrationObject):
    if migrationObject is None:
        raise Exception("migrationObject is None")
    mo_typeDict = {'DeploymentsMigration': DT_DEPLOYMENTS, 'DataEntityMigration': DT_DATA_ENTITIES, 'DeploymentDataMigration': DT_DEPLOYMENT_DATA}     
    return getAtomDocumentAsElementtree(migrationObject.doc_status, mo_typeDict[type(migrationObject).__name__], migrationObject.doc_owner, migrationObject.doc_name)

def getAtomDocumentHashByMO(migrationObject):
    if migrationObject is None:
        raise Exception("migrationObject is None")    
    mo_typeDict = {'DeploymentsMigration': DT_DEPLOYMENTS, 'DataEntityMigration': DT_DATA_ENTITIES, 'DeploymentDataMigration': DT_DEPLOYMENT_DATA}     
    text = _getAtomDocumentAsText(migrationObject.doc_status, mo_typeDict[type(migrationObject).__name__], migrationObject.doc_owner, migrationObject.doc_name)
    return calculateHash(text)

def getAtomDocumentHash(docStatus, docType, docOwner, docName):
    source = buildExistDocPath(docStatus, docType, docOwner, docName)
    text = _getDocument(source)
    return calculateHash(text)

def hasAtomDocumentSameHash(migrationObject):
    return getAtomDocumentHashByMO(migrationObject) == migrationObject.doc_hash

def getAtomDocumentByType(migrationObject, docType):
    if migrationObject is None:
        raise Exception("migrationObject is None")    
    return getAtomDocumentAsElementtree(migrationObject.doc_status, docType, migrationObject.doc_owner, migrationObject.doc_name)

def _getAtomDocumentAsText(docStatus, docType, docOwner, docName):
    source = buildExistDocPath(docStatus, docType, docOwner, docName)
    return _getDocument(source)

def getAtomDocumentAsElementtree(docStatus, docType, docOwner, docName):
    source = buildExistDocPath(docStatus, docType, docOwner, docName)
    return _getXMLDocument(source)

def _getXMLDocument(source):
    return XML(_getDocument(source))

def stringToTimestamp(timestring):
    '''
        Return a timestamp such as is returned by time.time().
        @param timestring: a time string formatted as '%Y-%m-%dT%H:%M:%SZ'
    '''    
    return datetime.datetime.fromtimestamp(time.mktime(time.strptime(timestring, datetime_format)))

def isoDateStringToTimeDate(datestring):
    '''
        Return a datatime.datatime instance.
        @param datestring: a date string formatted as '%Y-%m-%d'
    '''
    return datetime.datetime.strptime(datestring, date_format)

def isoDateTimeStringToTimeDate(timestring):
    '''
        Return a datatime.datatime instance.
        @param timestring: a time string formatted as '%Y-%m-%dT%H:%M:%SZ'
    '''
    return datetime.datetime.strptime(timestring, datetime_format)

def _getDocument(source):
    conn = HTTPConnection(host = ihost, port = iport)
    conn.connect()
    req = conn.request('GET', source)
    res = conn.getresponse()
    xmlDoc = res.read()
    '''
    print (xmlDoc)
    '''
    conn.close()
    return xmlDoc

def _returnNotNoneText(element):
    if element is None:
        return None
    return element.text

def findMolesCreationDate(resourceXML):
    creationDate = resourceXML.find('%sentity/%smolesISO/%screated' % (molesNS, molesNS, molesNS))
    return _returnNotNoneText(creationDate)

def findMolesLineage(dataEntityMigration):
    resourceXML = getAtomDocumentByMO(dataEntityMigration)
    lineage = resourceXML.find('%sentity/%smolesISO/%slineage' % (molesNS, molesNS, molesNS))
    if lineage is None:
        raise NoDataLineage(dataEntityMigration)
    return lineage.text

def extractMolesProviderID(migrationObject):
    resourceXML = getAtomDocumentByMO(migrationObject)
    provider_id = resourceXML.find('%sentity/%smolesISO/%sproviderID' % (molesNS, molesNS, molesNS))
    return _returnNotNoneText(provider_id)

def extractMolesQuality(migrationObject):
    resourceXML = getAtomDocumentByMO(migrationObject)
    quality = resourceXML.find('%sentity/%smolesISO/%squality' % (molesNS, molesNS, molesNS))
    return _returnNotNoneText(quality)

def extractMolesTemporalRange(migrationObject):
    resourceXML = getAtomDocumentByMO(migrationObject)
    temporal_range = resourceXML.find('%stemporalRange' % (molesNS))
    return _returnNotNoneText(temporal_range)

def extractMolesCreationDate(migrationObject):
    resourceXML = getAtomDocumentByMO(migrationObject)
    return findMolesCreationDate(resourceXML)

def extractQuality(dataEntityMigration):
    resourceXML = getAtomDocumentByMO(dataEntityMigration)
    quality = resourceXML.find('%sentity/%smolesISO/%squality' % (molesNS, molesNS, molesNS))
    return _returnNotNoneText(quality)

def extractUpdateFrequency(dataEntityMigration):
    resourceXML = getAtomDocumentByMO(dataEntityMigration)
    update_frequency = resourceXML.find('%sentity/%smolesISO/%supdateFrequency' % (molesNS, molesNS, molesNS))
    return _returnNotNoneText(update_frequency)

def extractContent(dataEntityMigration):
    """
        Returns a dictionary containing the div composing the
        <content> element in a dataentity document.
    """
    resourceXML = getAtomDocumentByMO(dataEntityMigration)
    content = resourceXML.find('%scontent' % (atomNS))
    text = _returnNotNoneText(content)
    contentDict = {}
    if text:
        doc = htmlParser.parse(unescape(text))
        for el in doc.findall('body//div'):    
            prop = el.get('property')
            if prop:
                if prop.startswith('cedacat'):
                    contentDict[prop.split(':')[1]] = escape(tostring(el))
    return contentDict

def _extractAuthors(authorsCSV):
    if authorsCSV is None:
        return []
    authors = authorsCSV.split(',')
    for index in range(len(authors)):
        authors[index] = authors[index].strip()
        if len(authors[index]) == 0:
            authors.remove(authors[index])
    return authors

def findAuthorsInResource(resourceMigration):
    '''
        Returns a dictionary with the following keys:
        'authors': a list of string representing the authors
        'contributors': a list of string representing the contributors
    '''
    ret = {}   
    resourceXML = getAtomDocumentByMO(resourceMigration)
    ret['authors'] = findAuthorInResource(resourceXML)
    ret['contributors'] = findContributorInResource(resourceXML)
    return ret

def findAuthorInResource(resourceXML): 
    author = resourceXML.find('%sauthor/%sname' % (atomNS, atomNS))
    return _returnNotNoneText(author)

def findContributorInResource(resourceXML): 
    contributors = resourceXML.find('%scontributor/%sname' % (atomNS, atomNS))
    return _returnNotNoneText(contributors)

def findPublishedDate(resourceMigration):
    resourceXML = getAtomDocumentByMO(resourceMigration)
    publishedDate = resourceXML.find('%spublished' % (atomNS))
    return _returnNotNoneText(publishedDate)

def findUpdatedDate(resourceMigration):
    resourceXML = getAtomDocumentByMO(resourceMigration)
    publishedDate = resourceXML.find('%supdated' % (atomNS))
    return _returnNotNoneText(publishedDate)

def findSummary(resourceMigration):
    """
        Returns the <entry><summary> tag of an atom document
        @param resourceMigration: a MigrationObject instance
        @return: the <summary> value or None if empty
    """
    resourceXML = getAtomDocumentByMO(resourceMigration)
    summary = resourceXML.find('%ssummary' % (atomNS))
    return _returnNotNoneText(summary)

def findID(dataEntXML):
    ent_id = dataEntXML.find('%sid' % (atomNS))
    return _returnNotNoneText(ent_id)

def _updateLinksDict(linksDict, link, linkMarker):
    if not linksDict.has_key(linkMarker):
        linksDict[linkMarker] = []
    rel = link.get('rel')
    if rel and rel.endswith('/' + linkMarker):
        linksDict[linkMarker].append({'href': link.get('href'), 'title': link.get('title')}) 

def _extractLinks(dataEntXML, markers):
    linksDict = {}
    links = dataEntXML.findall('%slink' % (atomNS))
    for link in links:
        for marker in markers:
            _updateLinksDict(linksDict, link, marker)        
    return linksDict

def findLinksInMigrationDocument(dataEntityMigration):
    dataEntXML = getAtomDocumentByMO(dataEntityMigration)
    linksDict = _extractLinks(dataEntXML, linkMarkers)
    return linksDict



def findDownloadLinksInMigrationDocument(migrationObject):
    """
        Return a list of dictionaries describing a <link rel="...DOWNLOAD..."> tag type
        Each dictionary has two keys: 'href' and 'title'
        @param migrationObject: the migration instance to retrieve and parse
        @return: a list of dictionaries
    """
    linksDict = findLinksInMigrationDocument(migrationObject)
    if linksDict.has_key('DOWNLOAD'):
        return linksDict['DOWNLOAD']    
    return {}       

def findAccessLinksInMigrationDocument(migrationObject):
    """
        Return a list of dictionaries describing a <link rel="...ACCESS..."> tag type
        Each dictionary has two keys: 'href' and 'title'
        @param migrationObject: the migration instance to retrieve and parse
        @return: a list of dictionaries
    """
    linksDict = findLinksInMigrationDocument(migrationObject)
    if linksDict.has_key('ACCESS'):
        return linksDict['ACCESS']     
    return {}    

def findDocumentationInMigrationDocument(migrationObject):
    """
        Return a list of dictionaries describing a <link rel="...DOCUMENTATION..."> tag type
        Each dictionary has two keys: 'href' and 'title'
        @param migrationObject: the migration instance to retrieve and parse
        @return: a list of dictionaries
    """
    linksDict = findLinksInMigrationDocument(migrationObject)
    if linksDict.has_key('DOCUMENTATION'):
        return linksDict['DOCUMENTATION']     
    return {}

def findDOIInMigrationDocument(migrationObject):
    """
        Return a dictionary describing a <link rel="...DOCUMENTATION..."> tag type
        The dictionary has two keys: 'href' and 'title'
        @param migrationObject: the migration instance to retrieve and parse
        @return: a dictionary relative to the DOI, None otherwise
    """
    for link in findDocumentationInMigrationDocument(migrationObject):
        if link['href'].startswith('doi:'):
            return link
    return None

def findDeploymentsInDE(dataEntityMigration):
    linksDict = findLinksInMigrationDocument(dataEntityMigration)
    links = _extractLinksByMarker(linksDict, 'Deployment')
    return [depName + '.atom' for depName in links]

def findSubTypeInDPT(resourceMigration):
    resourceXML = getAtomDocumentByMO(resourceMigration)
    categories = resourceXML.findall('%scategory' % (atomNS))
    for category in categories:
        if category.get("term") == "ATOM_SUBTYPE":
            return category.get("label")    
        
def extractTitle(deploymentMigration):
    resourceXML = getAtomDocumentByMO(deploymentMigration)
    title = resourceXML.find('%stitle' % (atomNS))
    return _returnNotNoneText(title)

def extractSummary(deploymentMigration, dataEntityMigration):
    resourceXML = getAtomDocumentByMO(deploymentMigration)
    summary = resourceXML.find('%ssummary' % (atomNS))
    ret = _returnNotNoneText(summary)
    if ret:
        return ret
    resourceXML = getAtomDocumentByMO(dataEntityMigration)
    summary = resourceXML.find('%ssummary' % (atomNS))
    return _returnNotNoneText(summary)

def extractGeographicExtentInMigrationDocument(migrationObject):
    """
        Extracts if existing the georss:where/gel:Enveloper/upper-lowerCorner elements.
        @param migrationObject: a migration object to retrieve to parse for data
        @return: None if no data are found, otherwise a dictionary with keys: 'east', 'north', 'west', 'south' where
        the values are float
    """
    resourceXML = getAtomDocumentByMO(migrationObject)
    upperCorner = resourceXML.find('%swhere/%sEnvelope/%supperCorner' % (georssNS, gmlNS, gmlNS))
    lowerCorner = resourceXML.find('%swhere/%sEnvelope/%slowerCorner' % (georssNS, gmlNS, gmlNS))
    ret = None
    if upperCorner != None and lowerCorner != None:
        upperCornerData = upperCorner.text.split()
        lowerCornerData = lowerCorner.text.split()
        ret = {'east': float(upperCornerData[0]), 'north': float(upperCornerData[1]), 'west': float(lowerCornerData[0]), 'south': float(lowerCornerData[1])}
    return ret

def findLinksInDeployment(migrationObject):
    """
        Returns a dictionary of links owned by the given dataEntity document
        @param deploymentMigration: a MigrationObject instance
        @return: a dictionary of links.
    """
    links = {}
    linksDict = findLinksInMigrationDocument(migrationObject)
    for marker in linkMarkers:    
        links[marker] = _extractLinksByMarker(linksDict, marker)
    return links

def _extractLinksByMarker(linksDict, marker):
    dpt = []
    if linksDict.has_key(marker):
        for link in linksDict[marker]:
            try:
                linkLongName = link['href'].split('/')[-1]
                linkName = linkLongName.rsplit('__ATOM__')[1]
                dpt.append(linkName)
            except Exception as ex:
                print "WARN - Cannot extractLinksByMarker %s" % (link)
    return dpt


def getResourceRefs(deploymentRefs):
    '''
        Returns a list of Elements representing the inner resource reference items
        @param resourceRefs: the name of the eXist collection name below the 'deployments' one
    '''  
    XMLDepl = _getXMLDocument(deploymentRefs)
    return XMLDepl.findall('%scollection/%sresource' % (existNS, existNS))

def getOwnerRefs(docStatus, docType, docOwner):
    '''
        Returns a list of Elements representing the inner resource reference items
        @param resourceRefs: the name of the eXist collection name below the 'deployments' one
    '''      
    XMLDepl = _getXMLDocument(buildExistOwnerPath(docStatus, docType, docOwner))
    return XMLDepl.findall('%scollection/%sresource' % (existNS, existNS))

def getTypeRefs(docStatus, docType):
    '''
        Returns a list of Elements representing the inner resource reference items
        @param resourceRefs: the name of the eXist collection name below the 'deployments' one
    '''      
    XMLDepl = _getXMLDocument(buildExistTypePath(docStatus, docType))
    return XMLDepl.findall('%scollection/%sresource' % (existNS, existNS))



def getCollectionRefs(publishedRefs):
    '''
        Returns a list of Elements representing the inner deployment reference items
        @param basePublished: the name of the eXist collection name below the 'published' one
    '''  
    XMLPubl = _getXMLDocument(publishedRefs)
    return XMLPubl.findall('%scollection/%scollection' % (existNS, existNS))

def getResource(source, resourceName):
    resourceSource = '%s/%s' % (source, resourceName)
    resourceDoc = _getDocument(resourceSource)
    return XML(resourceDoc)

def createDateTime(datetime):
    '''
        Creates a new DateTime instance.
        @param datetime: a datetime.datetime instance        
    '''
    dateTime = DateTime()
    dateTime.century = (datetime.year / 100) + 1
    dateTime.year = datetime.year
    dateTime.month = datetime.month        
    dateTime.day = datetime.day
    dateTime.hour = datetime.hour
    dateTime.minute = datetime.minute
    dateTime.second = datetime.second
    dateTime.timeZone = datetime.tzinfo        
    return dateTime        
        
def createDate(date):
    '''
        Creates a new Date instance.
        @param date: a datetime.datetime instance 
    '''
    idate = Date()
    idate.century = (date.year / 100) + 1
    idate.year = date.year
    idate.month = date.month        
    idate.day = date.day        
    return idate       
        
def createTM_Position(anyOther = None, date8601 = None, dateTime8601 = None, time8601 = None):
    '''
        Creates a new TM_Position instance
        @param anyOther: a TM_TemporalPosition instance
        @param date8601: a Date instance
        @param dateTime8601:a DateTime instance
        @param time8601: a Time instance   
    '''
    tm_position = TM_Position()
    if anyOther:
        tm_position.anyOther = anyOther
    if date8601:
        tm_position.date8601 = date8601  
    if dateTime8601:
        tm_position.dateTime8601 = dateTime8601
    if time8601:
        tm_position.time8601 = time8601
    return tm_position            

def createTM_Instant(position):
    '''
        Creates a new TM_Position instance
        @param position: a TM_Position instance
    '''
    tm_instant = TM_Instant()
    tm_instant.position = position
    return tm_instant

def createTM_Period(begin, end):
    '''
        Creates a new TM_Position instance
        @param position: a TM_Position instance
    '''
    tm_period = TM_Period()
    tm_period.begin = begin
    tm_period.end = end    
    return tm_period

def createCI_Address(deliveryPoint = None, electronicMailAddress = None, city = None, country = None, postalCode = None):
    '''
        Creates a new CI_Address instance
        @param deliveryPoint: an array of Strings
        @param electronicMailAddress: an array of Strings 
        @param city: a string
        @param country: a string                
        @param postalCode: a string        
    '''
    ci_address = CI_Address()
    if deliveryPoint:
        ci_address.deliveryPoint = deliveryPoint
    if electronicMailAddress:
        ci_address.electronicMailAddress = electronicMailAddress        
    if postalCode:
        ci_address.postalCode = postalCode        
    if city:
        ci_address.city = city        
    if country:
        ci_address.country = country        
    if postalCode:
        ci_address.postalCode = postalCode        
    return ci_address

def createCI_OnlineResource(linkage, name=None):
    '''
        Creates a new CI_OnlineResource instance
        @param linkage: a string (the URL class is associated with a String)
        @param name: a String
    '''
    ci_online_resource = CI_OnlineResource()
    ci_online_resource.linkage = linkage
    if name:
        ci_online_resource.name = name
    return ci_online_resource

def createCI_Telephone(voice=None, facsimile=None):
    '''
        Creates a new CI_Telephone instance
        @param voice: an array of strings        
        @param facsimile: an array of strings
    '''
    ci_telephone = CI_Telephone()
    if voice:
        ci_telephone.voice = voice
    if facsimile:
        ci_telephone.facsimile = voice        
    return ci_telephone

def createCI_Contact(phone, address = None, onlineResource = None):
    '''
        Creates a new CI_Contact instance
        @param phone: a CI_Telephone instance        
        @param address: a CI_Address instance
        @param onlineResource: a CI_OnlineResource instance
    '''
    ci_contact = CI_Contact()
    ci_contact.phone = phone
    if address:
        ci_contact.address = address
    if onlineResource:
        ci_contact.onlineResource = onlineResource        
    return ci_contact

def createCI_Individual(name = None, contactInfo = None):
    '''
        Creates a new CI_Individual instance
        @param name: a String
        @param contactInfo: an array of CI_Contact        
    '''    
    ci_party = CI_Individual()
    if name:
        ci_party.name = name
    if contactInfo:
        ci_party.contactInfo = contactInfo        
    return ci_party

def createCI_Organization(name = None, contactInfo = None):
    '''
        Creates a new CI_Individual instance
        @param name: a String
        @param contactInfo: an array of CI_Contact        
    '''    
    ci_party = CI_Organisation()
    if name:
        ci_party.name = name
    if contactInfo:
        ci_party.contactInfo = contactInfo        
    return ci_party

def createMO_Organization(name = None, contactInfo = None):
    '''
        Creates a new MO_Organization instance.
        TEMPORARILY RETURNS A CI_ORGANIZATION BECAUSE A DB SCHEMA PROBLEM!!!!
        @param name: a String
        @param contactInfo: an array of CI_Contact        
    '''       
    ci_party = CI_Organisation()
    if name:
        ci_party.name = name
    if contactInfo:
        ci_party.contactInfo = contactInfo         
    return ci_party

def createMO_ResponsiblePartyInfo(role, i_party):
    """
        @param role: a CI_RoleCode/MO_RoleValue assigned to this ResponsibleParty
        @param party: a list of MO_Organization/CI_Individual instances 
    """
    mo_responsableInfo = MO_ResponsiblePartyInfo()
    mo_responsableInfo.role = role
    mo_responsableInfo.party.extend(i_party)
    return mo_responsableInfo


def createCI_Date(dateType, date = None):
    """
        Creates a new CI_Date
        @param dateType: a CI_DateTypeCode value
        @param date: a DateTime instance
    """
    ci_date = CI_Date()
    ci_date.dateType = dateType
    if date:
        ci_date.date = date 
    return ci_date

def createCI_Citation(title, date = None, citedResponsibleParty = None):
    """
        Creates a new CI_Citation
        @param title: the CI_Citation title
        @param date: an array of CI_Date instances
        @param citedResponsibleParty: a list of CI_ResponsibleParty instances
    """    
    ci_citation = CI_Citation()
    ci_citation.title = title
    if date and type(date) == list:
        ci_citation.date = date
    if citedResponsibleParty:
        ci_citation.extend(citedResponsibleParty)
    return ci_citation

def createMD_Constraints(useLimitation = None):
    """
        Creates a new MD_Constrains
        @param useLimitation: a string array
    """ 
    md_constraints = MD_Constraints()
    if useLimitation and type(useLimitation) == list:
        md_constraints.useLimitation = useLimitation
    return md_constraints

def createMD_LegalConstraints(useLimitation = None, accessConstrains = None):
    """
        Creates a new MD_LegalConstrains
        @param useLimitation: a string array
        @param accessConstrains: an MD_RestrictionCode array 
    """ 
    md_legalconstraints = MD_LegalConstraints()
    if useLimitation and type(useLimitation) == list:
        md_legalconstraints.useLimitation = useLimitation
    if accessConstrains and type(accessConstrains) == list:
        md_legalconstraints.accessConstrains = accessConstrains        
    return md_legalconstraints

def createMD_Identifier(code, authority = None):
    """
        Creates a new MD_Identifier
        @param code: a String
        @param authority: a CI_Citation instance
    """
    md_identifier = MD_Identifier()
    md_identifier.code = code
    if authority:
        md_identifier.authority = authority
    return md_identifier

def createCI_ResponsibleParty(role, organizationName = None, individualName = None):
    """
        Creates a new CI_ResponsibeParty
        @param role: a CI_RoleCode
    """
    ci_responsible_party = CI_ResponsibleParty()
    ci_responsible_party.role = role
    if organizationName:
        ci_responsible_party.organisationName = organizationName
    if individualName:
        ci_responsible_party.individualName = individualName    
    return ci_responsible_party

def createMD_Metadata(date_stamp, contact, language = None):
    """
        Creates a new MD_Metadata
        @param date_stamp: a Date instance
        @param contacts: a CI_ResponsibleParty array instances
        @param language: a string
    """    
    md_metadata = MD_Metadata()
    md_metadata.dateStamp = date_stamp
    for item in contact:
        md_metadata.contact.append(item)
    if language:
        md_metadata.language = language    
    return md_metadata

def createMO_OnlineResource(linkage, name = None, function = None, description = None, applicationProfile = None):
    """
        Creates a new CEDA_Result
        @param linkage: the MO_OnlineResource.linkage.url.??? field
        @param name: the MO_OnlineResource.linkage.name field
        @param function: the MO_OnlineResource.function field 
        @param description: the MO_OnlineResource.description field
        @param applicationProfile: the MO_OnlineResource.applicationProfile field
    """
    on_line_resource = MO_OnlineResource()    
    on_line_resource.linkage = linkage
    if name: 
        on_line_resource.name = name
    if function:
        on_line_resource.function = function
    if description:
        on_line_resource.description = description
    if applicationProfile:
        on_line_resource.applicationProfile = applicationProfile
    return on_line_resource        

def createCEDA_Result(curation_category, internal_path, source = None):
    """
        Creates a new CEDA_Result
        @param curation_category: a CEDA_CurationValue instance
        @param internal_path: a String 
        @param source: an array of MO_OnlineResource instances
    """
    ceda_result = CEDA_Result()
    ceda_result.curationCategory = curation_category
    ceda_result.internalPath = internal_path           
    if source: 
        ceda_result.source = source
    return ceda_result



def createDQ_ConformanceResult(explanation, pass_, specification):
    """
        Creates a DQ_ConformanceResult instance
        @param explanation: a String
        @param pass_: a boolean value
        @param specification: a CI_Citation instance  
    """
    dq_conformanceResult = DQ_ConformanceResult()
    dq_conformanceResult.explanation = explanation
    dq_conformanceResult.pass_ = pass_
    dq_conformanceResult.specification = specification
    return dq_conformanceResult

def createDQ_Element(result):
    """
        Creates a DQ_Element instance
        @param result: a DQ_Result array (mix 1, max 2 items) 
    """
    dq_element = DQ_Element()
    if result and (type(result) == list) and (len(result) >= 1 and len(result) <= 2):
        dq_element.result = result
    return dq_element

def createEX_GeographicBoundingBox(east, north, west, south):
    """
        Creates an EX_GeographicBoundingBox instance
        @param east: the eastBoundLongitude attribute as float
        @param north: the northBoundLongitude attribute as float
        @param west: the westBoundLongitude attribute as float
        @param south: the southBoundLongitude attribute as float                
    """
    ex_geographic_bb = EX_GeographicBoundingBox()
    ex_geographic_bb.eastBoundLongitude = east
    ex_geographic_bb.northBoundLatitude = north
    ex_geographic_bb.westBoundLongitude = west
    ex_geographic_bb.southBoundLatitude = south
    return ex_geographic_bb
    
def createCEDA_Processing():
    ceda_processing = CEDA_Processing()
    return ceda_processing


def createCEDA_Instrument():
    ceda_instrument = CEDA_Instrument()
    return ceda_instrument

def createCEDA_CompositeProcess():
    ceda_cp = CEDA_CompositeProcess()
    return ceda_cp

def createCEDA_Acquisition():
    ceda_acquisition = CEDA_Acquisition()
    return ceda_acquisition

def createCEDA_Review(reviewer, reviewFrequency, reviewStatus):
    """
        Returns a new CEDA_Review
        @param reviewer: an MO_ResponsibilityPartyInfo
        @param reviewFrequency: a CEDA_ReviewFrequencyValue
        @param reviewStatus: a CEDA_ReviewStatusValue
    """
    ceda_review = CEDA_Review()
    ceda_review.reviewer = reviewer
    ceda_review.reviewFrequency = reviewFrequency 
    ceda_review.reviewStatus = reviewStatus           
    return ceda_review

def createCEDA_Project(abstract = None, publication_state = None, documentation = None, project_resource=None):
    ceda_project = CEDA_Project()
    if abstract:
        ceda_project.abstract = abstract 
    if publication_state:
        ceda_project.publicationState = publication_state        
    if documentation and type(documentation) == list:
        ceda_project.documentation = documentation
    if project_resource and type(project_resource) == list:
        ceda_project.projectResource = project_resource   
    return ceda_project