Changeset 8496

Timestamp:

08/08/12 14:52:24 (7 years ago)

Author:

mnagni

Message:

Incomplete - # 22534: Add versiojn number to the gui page
 http://team.ceda.ac.uk/trac/ceda/ticket/22534

Location:

mauRepo/MolesManager/trunk/cedaMoles

Files:

• MolesManager/moles3epb.py (modified) (2 diffs)
• libs/migration/processor/commons.py (modified) (59 diffs)
• libs/migration/processor/dataEntity.py (modified) (13 diffs)
• libs/migration/processor/deployment.py (modified) (35 diffs)
• libs/migration/processor/deployment_data.py (modified) (11 diffs)
• libs/migration/processor/loadResources.py (modified) (7 diffs)
• tests/cedamoles/mo/responsiblePartyInfo.py (modified) (2 diffs)
• tests/migration/commontest.py (modified) (4 diffs)
• tests/migration/loadresource.py (modified) (3 diffs)
• tests/migration/moles3epbtests.py (modified) (3 diffs)
• tests/migration/test_utils.py (modified) (3 diffs)
• tests/moles2gui/creationFactory.py (modified) (5 diffs)
• tests/moles2gui/om/period.py (modified) (3 diffs)

mauRepo/MolesManager/trunk/cedaMoles/MolesManager/moles3epb.py

@@ -46 +46 @@
 from ea_model.ceda_metadatamodel.ceda_project.ceda_project import CEDA_Project
 from cedaMoles.MolesManager.codelist import MM_RoleValue, getCLValue
-from cedaMoles.libs.migration.processor.commons import fromPhenomenonTimeToString
+from cedaMoles.libs.migration.processor.commons import from_pt_to_string
 from datetime import datetime
 from ascore.utils import synchAttributes
@@ -405 +405 @@
             
         pt =  member.phenomenonTime
-        ptString = fromPhenomenonTimeToString(pt)
+        ptString = from_pt_to_string(pt)
         if ptString[0] is not None:                    
             ptStart.append(datetime.strptime(ptString[0], dateFormat))

mauRepo/MolesManager/trunk/cedaMoles/libs/migration/processor/commons.py

@@ -118 +118 @@
 MOLES_NS = "{http://ndg.nerc.ac.uk/schema/moles2beta}"
 #htmlNS = "{http://www.w3.org/1999/xhtml}"
-GEORSS_NS="{http://www.georss.org/georss/10}"
-GML_NS="{http://www.opengis.net/gml}"
+GEORSS_NS = "{http://www.georss.org/georss/10}"
+GML_NS = "{http://www.opengis.net/gml}"
 DATE_FORMAT = '%Y-%m-%d'
 DATETIME_FORMAT = DATE_FORMAT + 'T%H:%M:%SZ'
@@ -134 +134 @@
                                  namespaceHTMLElements=False)
 
-def calculateHash(text):
+def calculate_hash(text):
     """
         Returns an md5 hexadecimal representation of the given text
@@ -144 +144 @@
     return encoder.hexdigest()
 
-def buildExistDocPath(doc_status, doc_type, doc_owner, doc_name):
+def build_exist_doc_path(doc_status, doc_type, doc_owner, doc_name):
     '''
         @param doc_status: one value from commons.docStatus
@@ -151 +151 @@
         @param doc_name: one value from commons.DOC_OWNERS        
     '''        
-    return '%s/%s' % (buildExistOwnerPath(doc_status, doc_type, doc_owner), doc_name)
-
-def buildExistOwnerPath(doc_status, doc_type, doc_owner):
+    return '%s/%s' % (_build_exist_owner_path(doc_status, doc_type, doc_owner), doc_name)
+
+def _build_exist_owner_path(doc_status, doc_type, doc_owner):
     '''
         @param doc_status: one value from commons.docStatus
@@ -159 +159 @@
         @param doc_owner: one value from commons.DOC_OWNERS
     '''        
-    return '%s/%s' % (buildExistTypePath(doc_status, doc_type), doc_owner)
-
-def buildExistTypePath(doc_status, doc_type):
+    return '%s/%s' % (build_exist_type_path(doc_status, doc_type), doc_owner)
+
+def build_exist_type_path(doc_status, doc_type):
     '''
         @param doc_status: one value from commons.docStatus
         @param doc_type: one value from commons.docCollections 
     '''        
-    return '%s/%s' % (buildExistStatusPath(doc_status), doc_type)
-
-def buildExistStatusPath(doc_status):
-    '''
-        @param doc_status: one value from commons.docStatus 
-    '''        
-    return '/exist/rest/atoms/%s' % (doc_status)
-
-def getAtomDocumentByMO(migration_object):
+    return '%s/%s' % ('/exist/rest/atoms/%s' % (doc_status), doc_type)
+
+def _get_atom_document_by_mo(migration_object):
     if migration_object is None:
         raise Exception("migrationObject is None")
@@ -180 +174 @@
                    'DataEntityMigration': DT_DATA_ENTITIES, \
                    'DeploymentDataMigration': DT_DEPLOYMENT_DATA}     
-    return getAtomDocumentAsElementtree(migration_object.doc_status, \
+    return get_atom_document_as_elementtree(migration_object.doc_status, \
                                     mo_type_dict[type(migration_object).__name__], \
                                     migration_object.doc_owner, migration_object.doc_name)
 
-def getAtomDocumentHashByMO(migration_object):
+def get_atom_document_hash_by_mo(migration_object):
     if migration_object is None:
         raise Exception("migrationObject is None")    
@@ -193 +187 @@
                                   mo_type_dict[type(migration_object).__name__],\
                                    migration_object.doc_owner, migration_object.doc_name)
-    return calculateHash(text)
-
-def getAtomDocumentHash(doc_status, doc_type, doc_owner, doc_name):
-    source = buildExistDocPath(doc_status, doc_type, doc_owner, doc_name)
-    text = _get_document(source)
-    return calculateHash(text)
-
-def hasMOBeenProcessed(migration_object):
+    return calculate_hash(text)
+
+def has_mo_been_processed(migration_object):
     '''
         Checks if a migration object has been already processed.
@@ -217 +206 @@
     return True
 
-def hasMOSameHash(migration_object):
+def has_mo_same_hash(migration_object):
     '''
         Checks if a migration object has changed.
@@ -225 +214 @@
             same of the migrationObject, otherwise False
     '''
-    if not hasMOBeenProcessed(migration_object):
+    if not has_mo_been_processed(migration_object):
         return False
-    return getAtomDocumentHashByMO(migration_object) == migration_object.doc_hash
-
-def getAtomDocumentByType(migration_object, doc_type):
-    if migration_object is None:
-        raise Exception("migrationObject is None")    
-    return getAtomDocumentAsElementtree(migration_object.doc_status, \
-                                        doc_type, migration_object.doc_owner, \
-                                        migration_object.doc_name)
+    return get_atom_document_hash_by_mo(migration_object) == migration_object.doc_hash
 
 def _get_atom_document_as_text(doc_status, doc_type, doc_owner, doc_name):
-    source = buildExistDocPath(doc_status, doc_type, doc_owner, doc_name)
+    source = build_exist_doc_path(doc_status, doc_type, doc_owner, doc_name)
     return _get_document(source)
 
-def getAtomDocumentAsElementtree(doc_status, doc_type, doc_owner, doc_name):
-    source = buildExistDocPath(doc_status, doc_type, doc_owner, doc_name)
+def get_atom_document_as_elementtree(doc_status, doc_type, doc_owner, doc_name):
+    source = build_exist_doc_path(doc_status, doc_type, doc_owner, doc_name)
     return _get_xml_document(source)
 
@@ -275 +257 @@
     conn = HTTPConnection(host = HOST, port = PORT)
     conn.connect()
-    #req = conn.request('GET', source)
+    conn.request('GET', source)
     res = conn.getresponse()
     xml_doc = res.read()
-    '''
-    print (xmlDoc)
-    '''
     conn.close()
     return xml_doc
@@ -289 +268 @@
     return element.text
 
-def findMolesCreationDate(resource_xml):
+def find_moles_creation_date(resource_xml):
     creation_date = resource_xml.find('%sentity/%smolesISO/%screated' \
                                     % (MOLES_NS, MOLES_NS, MOLES_NS))
     return _return_not_none_text(creation_date)
 
-def findMolesPublishedDate(resource_xml):
+def _find_moles_published_date(resource_xml):
     creation_date = resource_xml.find('%sentity/%smolesISO/%spublished' \
                                     % (MOLES_NS, MOLES_NS, MOLES_NS))
     return _return_not_none_text(creation_date)
 
-def findMolesLineage(data_entity_migration):
-    resource_xml = getAtomDocumentByMO(data_entity_migration)
+def find_moles_lineage(data_entity_migration):
+    resource_xml = _get_atom_document_by_mo(data_entity_migration)
     lineage = resource_xml.find('%sentity/%smolesISO/%slineage' \
                                % (MOLES_NS, MOLES_NS, MOLES_NS))
@@ -307 +286 @@
     return lineage.text
 
-def extractMolesProviderID(migration_object):
-    resource_xml = getAtomDocumentByMO(migration_object)
+def extract_moles_provider_id(migration_object):
+    resource_xml = _get_atom_document_by_mo(migration_object)
     provider_id = resource_xml.find('%sentity/%smolesISO/%sproviderID' \
                                    % (MOLES_NS, MOLES_NS, MOLES_NS))
     return _return_not_none_text(provider_id)
 
-def extractMolesQuality(migration_object):
-    resourceXML = getAtomDocumentByMO(migration_object)
-    quality = resourceXML.find('%sentity/%smolesISO/%squality' \
-                               % (MOLES_NS, MOLES_NS, MOLES_NS))
-    return _return_not_none_text(quality)
-
-def extractMolesTemporalRange(migration_object):
-    resource_xml = getAtomDocumentByMO(migration_object)
+def extract_moles_temporal_range(migration_object):
+    resource_xml = _get_atom_document_by_mo(migration_object)
     temporal_range = resource_xml.find('%stemporalRange' % (MOLES_NS))
     return _return_not_none_text(temporal_range)
 
-def extractMolesCreationDate(migration_object):
-    resource_xml = getAtomDocumentByMO(migration_object)
-    return findMolesCreationDate(resource_xml)
-
-def extractMolesPublishedDate(migration_object):
-    resource_xml = getAtomDocumentByMO(migration_object)
-    return findMolesPublishedDate(resource_xml)
-
-def extractQuality(data_entity_migration):
-    resource_xml = getAtomDocumentByMO(data_entity_migration)
+def extract_moles_creation_date(migration_object):
+    resource_xml = _get_atom_document_by_mo(migration_object)
+    return find_moles_creation_date(resource_xml)
+
+def extract_moles_published_date(migration_object):
+    resource_xml = _get_atom_document_by_mo(migration_object)
+    return _find_moles_published_date(resource_xml)
+
+def extract_quality(data_entity_migration):
+    resource_xml = _get_atom_document_by_mo(data_entity_migration)
     quality = resource_xml.find('%sentity/%smolesISO/%squality' \
                                % (MOLES_NS, MOLES_NS, MOLES_NS))
     return _return_not_none_text(quality)
 
-def extractUpdateFrequency(data_entity_migration):
-    resource_xml = getAtomDocumentByMO(data_entity_migration)
+def extract_update_frequency(data_entity_migration):
+    resource_xml = _get_atom_document_by_mo(data_entity_migration)
     update_frequency = resource_xml.find('%sentity/%smolesISO/%supdateFrequency' \
                                         % (MOLES_NS, MOLES_NS, MOLES_NS))
     return _return_not_none_text(update_frequency)
 
-def extractContent(data_entity_migration):
+def extract_content(data_entity_migration):
     """
         Returns a dictionary containing the div composing the
         <content> element in a dataentity document.
     """
-    resource_xml = getAtomDocumentByMO(data_entity_migration)
+    resource_xml = _get_atom_document_by_mo(data_entity_migration)
     content = resource_xml.find('%scontent' % (ATOM_NS))
     text = _return_not_none_text(content)
@@ -362 +335 @@
     return contentDict
 
-def findAuthorsInResource(resource_migration):
+def find_authors_in_resource(resource_migration):
     '''
         Returns a dictionary with the following keys:
@@ -369 +342 @@
     '''
     ret = {}   
-    resource_xml = getAtomDocumentByMO(resource_migration)
-    ret['authors'] = findAuthorInResource(resource_xml)
-    ret['contributors'] = findContributorInResource(resource_xml)
+    resource_xml = _get_atom_document_by_mo(resource_migration)
+    ret['authors'] = _find_author_in_resource(resource_xml)
+    ret['contributors'] = _find_contributor_in_resource(resource_xml)
     return ret
 
-def findAuthorInResource(resource_xml): 
+def _find_author_in_resource(resource_xml): 
     author = resource_xml.find('%sauthor/%sname' % (ATOM_NS, ATOM_NS))
     return _return_not_none_text(author)
 
-def findContributorInResource(resource_xml): 
+def _find_contributor_in_resource(resource_xml): 
     contributors = resource_xml.find('%scontributor/%sname' % (ATOM_NS, ATOM_NS))
     return _return_not_none_text(contributors)
 
-def findPublishedDate(resource_migration):
-    resource_xml = getAtomDocumentByMO(resource_migration)
+def find_published_date(resource_migration):
+    resource_xml = _get_atom_document_by_mo(resource_migration)
     publishedDate = resource_xml.find('%spublished' % (ATOM_NS))
     return _return_not_none_text(publishedDate)
 
-def findUpdatedDate(resource_migration):
-    resource_xml = getAtomDocumentByMO(resource_migration)
+def find_updated_date(resource_migration):
+    resource_xml = _get_atom_document_by_mo(resource_migration)
     publishedDate = resource_xml.find('%supdated' % (ATOM_NS))
     return _return_not_none_text(publishedDate)
 
-def findSummary(resource_migration):
+def find_summary(resource_migration):
     """
         Returns the <entry><summary> tag of an atom document
@@ -398 +371 @@
         @return: the <summary> value or None if empty
     """
-    resource_xml = getAtomDocumentByMO(resource_migration)
+    resource_xml = _get_atom_document_by_mo(resource_migration)
     summary = resource_xml.find('%ssummary' % (ATOM_NS))
     return _return_not_none_text(summary)
 
-def findID(data_ent_xml):
+def find_id(data_ent_xml):
     ent_id = data_ent_xml.find('%sid' % (ATOM_NS))
     return _return_not_none_text(ent_id)
@@ -422 +395 @@
     return links_dict
 
-def findLinksInMigrationDocument(data_entity_migration):
-    data_ent_XML = getAtomDocumentByMO(data_entity_migration)
+def find_links_in_migration_document(data_entity_migration):
+    data_ent_XML = _get_atom_document_by_mo(data_entity_migration)
     links_dict = _extract_links(data_ent_XML, LINK_MARKERS)
     return links_dict
@@ -429 +402 @@
 
 
-def findDownloadLinksInMigrationDocument(migration_object):
+def find_download_links_in_migration_document(migration_object):
     """
         Return a list of dictionaries describing a <link rel="...DOWNLOAD..."> tag type
@@ -436 +409 @@
         @return: a list of dictionaries
     """
-    links_dict = findLinksInMigrationDocument(migration_object)
+    links_dict = find_links_in_migration_document(migration_object)
     if links_dict.has_key('DOWNLOAD'):
         return links_dict['DOWNLOAD']    
     return {}       
 
-def findAccessLinksInMigrationDocument(migration_object):
+def find_access_links_in_migration_document(migration_object):
     """
         Return a list of dictionaries describing a <link rel="...ACCESS..."> tag type
@@ -448 +421 @@
         @return: a list of dictionaries
     """
-    links_dict = findLinksInMigrationDocument(migration_object)
+    links_dict = find_links_in_migration_document(migration_object)
     if links_dict.has_key('ACCESS'):
         return links_dict['ACCESS']     
     return {}    
 
-def findDocumentationInMigrationDocument(migration_object):
+def find_documentation_in_migration_document(migration_object):
     """
         Return a list of dictionaries describing a <link rel="...DOCUMENTATION..."> 
@@ -461 +434 @@
         @return: a list of dictionaries
     """
-    links_dict = findLinksInMigrationDocument(migration_object)
+    links_dict = find_links_in_migration_document(migration_object)
     if links_dict.has_key('DOCUMENTATION'):
         return links_dict['DOCUMENTATION']     
     return {}
 
-def findDOIInMigrationDocument(migration_object):
+def find_doi_in_migration_document(migration_object):
     """
         Return a dictionary describing a <link rel="...DOCUMENTATION..."> tag type
@@ -473 +446 @@
         @return: a dictionary relative to the DOI, None otherwise
     """
-    for link in findDocumentationInMigrationDocument(migration_object):
+    for link in find_documentation_in_migration_document(migration_object):
         if link['href'].startswith('http://dx.doi.org/doi:'):
             return link
     return None
 
-def findDeploymentsInDE(data_entity_migration):
-    links_dict = findLinksInMigrationDocument(data_entity_migration)
+def find_deployments_in_de(data_entity_migration):
+    links_dict = find_links_in_migration_document(data_entity_migration)
     links = _extract_links_by_marker(links_dict, 'Deployment')
     return [depName + '.atom' for depName in links]
 
-def findSubTypeInDPT(resourceMigration):
-    resource_xml = getAtomDocumentByMO(resourceMigration)
+def find_subtype_in_dpt(resourceMigration):
+    resource_xml = _get_atom_document_by_mo(resourceMigration)
     categories = resource_xml.findall('%scategory' % (ATOM_NS))
     for category in categories:
@@ -490 +463 @@
             return category.get("label")    
         
-def extractTitle(deploymentMigration):
-    resource_xml = getAtomDocumentByMO(deploymentMigration)
+def extract_title(deploymentMigration):
+    resource_xml = _get_atom_document_by_mo(deploymentMigration)
     title = resource_xml.find('%stitle' % (ATOM_NS))
     return _return_not_none_text(title)
 
-def extractSummary(migrationObject):
-    resource_xml = getAtomDocumentByMO(migrationObject)
+def extract_summary(migrationObject):
+    resource_xml = _get_atom_document_by_mo(migrationObject)
     summary = resource_xml.find('%ssummary' % (ATOM_NS))
     return _return_not_none_text(summary)
 
-def extractGeographicExtentInMigrationDocument(migration_object):
+def extract_ge_in_migration_doc(migration_object):
     """
         Extracts if existing the georss:where/gel:Enveloper/upper-lowerCorner elements.
@@ -508 +481 @@
         the values are float
     """
-    resource_xml = getAtomDocumentByMO(migration_object)
+    resource_xml = _get_atom_document_by_mo(migration_object)
     upper_corner = resource_xml.find('%swhere/%sEnvelope/%supperCorner' \
                                    % (GEORSS_NS, GML_NS, GML_NS))
@@ -521 +494 @@
     return ret
 
-def findLinksInDeployment(migration_object):
+def find_links_in_deployment(migration_object):
     """
         Returns a dictionary of links owned by the given dataEntity document
@@ -528 +501 @@
     """
     links = {}
-    links_dict = findLinksInMigrationDocument(migration_object)
+    links_dict = find_links_in_migration_document(migration_object)
     for marker in LINK_MARKERS:    
         links[marker] = _extract_links_by_marker(links_dict, marker)
@@ -548 +521 @@
     return dpt
 
-
-def getResourceRefs(deployment_refs):
-    '''
-        Returns a list of Elements representing the inner resource reference items
-        @param resourceRefs: the name of the eXist collection name below the 
-        'deployments' one
-    '''  
-    xml_depl = _get_xml_document(deployment_refs)
-    return xml_depl.findall('%scollection/%sresource' % (EXIST_NS, EXIST_NS))
-
-def getOwnerRefs(doc_status, doc_type, doc_owner):
+def get_owner_refs(doc_status, doc_type, doc_owner):
     '''
         Returns a list of Elements representing the inner resource reference items
@@ -564 +527 @@
         'deployments' one
     '''      
-    xml_depl = _get_xml_document(buildExistOwnerPath(doc_status, doc_type, doc_owner))
+    xml_depl = _get_xml_document(_build_exist_owner_path(doc_status, doc_type, doc_owner))
     return xml_depl.findall('%scollection/%sresource' % (EXIST_NS, EXIST_NS))
 
-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
-    '''      
-    xml_depl = _get_xml_document(buildExistTypePath(docStatus, docType))
-    return xml_depl.findall('%scollection/%sresource' % (EXIST_NS, EXIST_NS))
-
-
-
-def getCollectionRefs(published_refs):
+def get_collection_refs(published_refs):
     '''
         Returns a list of Elements representing the inner deployment reference items
@@ -587 +539 @@
     return xml_publ.findall('%scollection/%scollection' % (EXIST_NS, EXIST_NS))
 
-def getResource(source, resource_name):
-    resource_source = '%s/%s' % (source, resource_name)
-    resource_doc = _get_document(resource_source)
-    return XML(resource_doc)
-
-def createMD_Keywords(keywords, k_type=None, thesaurusName=None):
+def create_md_keywords(keywords, k_type=None, thesaurusName=None):
     '''
         Creates a new MD_Keywords instance.
@@ -606 +553 @@
     
 
-def createDateTime(datetime):
+def create_datetime(datetime):
     '''
         Creates a new DateTime instance.
@@ -624 +571 @@
     return dateTime        
         
-def createDate(date):
+def create_date(date):
     '''
         Creates a new Date instance.
@@ -636 +583 @@
     return idate       
         
-def createTM_Position(anyOther = None, \
+def create_tm_position(anyOther = None, \
                       date8601 = None, \
                       dateTime8601 = None, \
@@ -658 +605 @@
     return tm_position            
 
-def createTM_Instant(position):
+def create_tm_instant(position):
     '''
         Creates a new TM_Position instance
@@ -667 +614 @@
     return tm_instant
 
-def createTM_Period(begin, end):
+def create_tm_period(begin, end):
     '''
         Creates a new TM_Position instance
@@ -677 +624 @@
     return tm_period
 
-def createCI_Address(deliveryPoint = None, electronicMailAddress = None, \
+def create_ci_address(deliveryPoint = None, electronicMailAddress = None, \
                      city = None, country = None, postalCode = None):
     '''
@@ -702 +649 @@
     return ci_address
 
-def createCI_OnlineResource(linkage, name=None):
+def create_ci_onlineresource(linkage, name=None):
     '''
         Creates a new CI_OnlineResource instance
@@ -714 +661 @@
     return ci_online_resource
 
-def createCI_Telephone(voice=None, facsimile=None):
+def create_ci_telephone(voice=None, facsimile=None):
     '''
         Creates a new CI_Telephone instance
@@ -727 +674 @@
     return ci_telephone
 
-def createCI_Contact(phone, address = None, onlineResource = None):
+def create_ci_contact(phone, address = None, onlineResource = None):
     '''
         Creates a new CI_Contact instance
@@ -742 +689 @@
     return ci_contact
 
-def createMO_Individual(name = None, contactInfo = None):
+def create_mo_individual(name = None, contactInfo = None):
     '''
         Creates a new MO_Individual instance
@@ -755 +702 @@
     return ci_party
 
-def createMO_Organization(name = None, contactInfo = None):
+def create_mo_organization(name = None, contactInfo = None):
     '''
         Creates a new MO_Organization instance.
@@ -768 +715 @@
     return ci_party
 
-def createMO_ResponsiblePartyInfo(role, i_party):
+def create_mo_responsible_party_info(role, i_party):
     """
         @param role: a CI_RoleCode/MO_RoleValue assigned to this ResponsibleParty
@@ -779 +726 @@
 
 
-def createCI_Date(dateType, date = None):
+def create_ci_date(dateType, date = None):
     """
         Creates a new CI_Date
@@ -791 +738 @@
     return ci_date
 
-def createCI_Citation(title, date = None, icitedResponsibleParty = None):
+def create_ci_citation(title, date = None, icitedResponsibleParty = None):
     """
         Creates a new CI_Citation
@@ -806 +753 @@
     return ci_citation
 
-def createMD_Constraints(useLimitation = None):
+def create_md_constraints(useLimitation = None):
     """
         Creates a new MD_Constrains
@@ -816 +763 @@
     return md_constraints
 
-def createMD_LegalConstraints(useLimitation = None, accessConstrains = None):
+def create_md_legal_constraints(useLimitation = None, accessConstrains = None):
     """
         Creates a new MD_LegalConstrains
@@ -829 +776 @@
     return md_legalconstraints
 
-def createMD_Identifier(code, authority = None):
+def create_md_identifier(code, authority = None):
     """
         Creates a new MD_Identifier
@@ -843 +790 @@
     return md_identifier
 
-def createCI_ResponsibleParty(role, organizationName = None, individualName = None):
+def create_ci_responsible_party(role, organizationName = None, individualName = None):
     """
         Creates a new CI_ResponsibeParty
@@ -856 +803 @@
     return ci_responsible_party
 
-def createMD_Metadata(date_stamp, contact, language = None):
+def create_md_metadata(date_stamp, contact, language = None):
     """
         Creates a new MD_Metadata
@@ -871 +818 @@
     return md_metadata
 
-def createMO_OnlineResource(linkage, instance = None, name = None, function = None, \
+def create_mo_online_resource(linkage, instance = None, name = None, function = None, \
                             description = None, applicationProfile = None):
     """
@@ -895 +842 @@
     return on_line_resource        
 
-def createCEDA_Result(curation_category, internal_path, source = None):
+def create_ceda_result(curation_category, internal_path, source = None):
     """
         Creates a new CEDA_Result
@@ -911 +858 @@
 
 
-def createDQ_ConformanceResult(explanation, pass_, specification):
+def create_dq_conformance_result(explanation, pass_, specification):
     """
         Creates a DQ_ConformanceResult instance
@@ -924 +871 @@
     return dq_conformanceResult
 
-def createDQ_Element(result):
+def create_dq_element(result):
     """
         Creates a DQ_Element instance
@@ -934 +881 @@
     return dq_element
 
-def createEX_GeographicBoundingBox(east, north, west, south):
+def create_ex_geographic_boundingbox(east, north, west, south):
     """
         Creates an EX_GeographicBoundingBox instance
@@ -949 +896 @@
     return ex_geographic_bb
     
-def createCEDA_Processing():
+def create_ceda_processing():
     ceda_processing = CEDA_Processing()
     return ceda_processing
 
 
-def createCEDA_Instrument():
+def create_ceda_instrument():
     ceda_instrument = CEDA_Instrument()
     return ceda_instrument
 
-def createCEDA_CompositeProcess():
+def create_ceda_composite_process():
     ceda_cp = CEDA_CompositeProcess()
     return ceda_cp
 
-def createCEDA_Acquisition():
+def create_ceda_acquisition():
     ceda_acquisition = CEDA_Acquisition()
     return ceda_acquisition
 
-def createCEDA_Review(reviewer, reviewFrequency, reviewStatus):
+def create_ceda_review(reviewer, reviewFrequency, reviewStatus):
     """
         Returns a new CEDA_Review
@@ -979 +926 @@
     return ceda_review
 
-def createCEDA_Project(abstract = None, publication_state = None, \
+def create_ceda_project(abstract = None, publication_state = None, \
                        documentation = None, project_resource=None):
     ceda_project = CEDA_Project()
@@ -992 +939 @@
     return ceda_project
 
-def fromDateStringToPhenomenonTime(doc_phenomenon_time):
+def from_date_string_to_pt(doc_phenomenon_time):
     """
         Transforms a date string like '2002-07-22' (startDate) in a TM_Instant instance or   
@@ -1002 +949 @@
         if '/' in doc_phenomenon_time:
             period = doc_phenomenon_time.split('/')
-            begin_date = createDate(isoDateStringToTimeDate(period[0]))
-            begin_position = createTM_Position(date8601 = begin_date)
-            begin_tm_instant = createTM_Instant(begin_position)
+            begin_date = create_date(isoDateStringToTimeDate(period[0]))
+            begin_position = create_tm_position(date8601 = begin_date)
+            begin_tm_instant = create_tm_instant(begin_position)
             
-            end_date = createDate(isoDateStringToTimeDate(period[1]))
-            end_position = createTM_Position(date8601 = end_date)
-            end_tm_instant = createTM_Instant(end_position)
+            end_date = create_date(isoDateStringToTimeDate(period[1]))
+            end_position = create_tm_position(date8601 = end_date)
+            end_tm_instant = create_tm_instant(end_position)
             
-            pt = createTM_Period(begin_tm_instant, end_tm_instant)
+            pt = create_tm_period(begin_tm_instant, end_tm_instant)
         else:
-            tm_position = createTM_Position(date8601 = \
-                                            createDate(isoDateStringToTimeDate(doc_phenomenon_time)))
-            pt = createTM_Instant(tm_position)
+            tm_position = create_tm_position(date8601 = \
+                                            create_date(isoDateStringToTimeDate(doc_phenomenon_time)))
+            pt = create_tm_instant(tm_position)
         return pt
 
-def fromPhenomenonTimeToString(phenomenonTime):
+def from_pt_to_string(phenomenonTime):
     """
         Transforms a TM_Instant instance in a date string like '2002-07-22' (startDate) or   
@@ -1036 +983 @@
     return startDate, endDate
 
-def comparePhenomenonTimes(p1, p2):
-    s1 = fromPhenomenonTimeToString(p1)
-    s2 = fromPhenomenonTimeToString(p2)
+def compare_phenomenon_times(p1, p2):
+    s1 = from_pt_to_string(p1)
+    s2 = from_pt_to_string(p2)
     return s1[0] == s2[0] and s1[1] == s2[1] 
 
@@ -1045 +992 @@
     return str(datetime.date(int(idate.year), int(idate.month), int(idate.day)))
 
-def fromGeographicBoundingBoxToString(gbb):
+def _from_geographic_bb_to_string(gbb):
     if gbb is None:
         return None
@@ -1052 +999 @@
     
 def compareGeographicBoundingBoxes(gb1, gb2):
-    return fromGeographicBoundingBoxToString(gb1) == fromGeographicBoundingBoxToString(gb2)
+    return _from_geographic_bb_to_string(gb1) == _from_geographic_bb_to_string(gb2)

mauRepo/MolesManager/trunk/cedaMoles/libs/migration/processor/dataEntity.py

@@ -34 +34 @@
     migrationObjectDescription, NoAssociatedDeployments,\
     NoGeographicalExtensionException, NoCitationException
-from cedaMoles.libs.migration.processor.commons import findDeploymentsInDE,\
-    createMD_Identifier, extractContent,\
-    hasMOSameHash, createCI_Citation, createCI_Date, findPublishedDate,\
-    isoDateTimeStringToTimeDate, findUpdatedDate, createDate,\
-    calculateHash, findDOIInMigrationDocument,\
-    hasMOBeenProcessed, getAtomDocumentHashByMO, extractTitle, extractSummary,\
-    createEX_GeographicBoundingBox, fromDateStringToPhenomenonTime,\
-    comparePhenomenonTimes, compareGeographicBoundingBoxes
+from cedaMoles.libs.migration.processor.commons import find_deployments_in_de,\
+    create_md_identifier, extract_content,\
+    has_mo_same_hash, create_ci_citation, create_ci_date, find_published_date,\
+    isoDateTimeStringToTimeDate, find_updated_date, create_date,\
+    calculate_hash, find_doi_in_migration_document,\
+    has_mo_been_processed, get_atom_document_hash_by_mo, extract_title, extract_summary,\
+    create_ex_geographic_boundingbox, from_date_string_to_pt,\
+    compare_phenomenon_times, compareGeographicBoundingBoxes
 from cedaMoles.libs.migration.processor.deployment import DeploymentProcessor
 from logging import StreamHandler
@@ -69 +69 @@
         #    raise MigrationObjectException("DataEntityProcessor cannot process an None item")
         self._dataEntityMigration = dataEntityMigration        
-        self._dataEntityHasSameHash = hasMOSameHash(self._dataEntityMigration)    
-        self._dataEntityHasBeenProcessed = hasMOBeenProcessed(self._dataEntityMigration)   
+        self._dataEntityHasSameHash = has_mo_same_hash(self._dataEntityMigration)    
+        self._dataEntityHasBeenProcessed = has_mo_been_processed(self._dataEntityMigration)   
         self.epbRepo = epbRepo
         self._report = []
@@ -80 +80 @@
             east, north = upperCornerData.split()
             west, south = lowerCornerData.split()
-            geographicExtent = createEX_GeographicBoundingBox(float(east), float(north), \
+            geographicExtent = create_ex_geographic_boundingbox(float(east), float(north), \
                                                               float(west), float(south))
             
@@ -97 +97 @@
         if end is not None:
             dateString = '%s/%s' % (start, end)
-        pt = fromDateStringToPhenomenonTime(dateString)
+        pt = from_date_string_to_pt(dateString)
         
         if pt is not None and ceda_observationCollection.phenomenonTime is not None \
             and (len(ceda_observationCollection.phenomenonTime) == 0 \
                  or (len(ceda_observationCollection.phenomenonTime) == 1 and \
-                     not comparePhenomenonTimes(ceda_observationCollection.phenomenonTime[0], pt))):
+                     not compare_phenomenon_times(ceda_observationCollection.phenomenonTime[0], pt))):
             self.epbRepo.moles3EPB.updateCedaObject(ceda_observationCollection, {'phenomenonTime': pt})        
 
     def _assignDescription(self, ceda_observationCollection):
-        description = extractSummary(self._dataEntityMigration)
+        description = extract_summary(self._dataEntityMigration)
             
         if description:
@@ -112 +112 @@
     
     def _processTitle(self, ceda_observationCollection):
-        ititle = extractTitle(self._dataEntityMigration)
+        ititle = extract_title(self._dataEntityMigration)
         if ceda_observationCollection.identifier:
             for ident in ceda_observationCollection.identifier:
@@ -122 +122 @@
  
         #Else create new
-        i_citation = createCI_Citation(title = CEDA_TITLE)
-        newIdentifier = createMD_Identifier(code = ititle, authority=i_citation)
+        i_citation = create_ci_citation(title = CEDA_TITLE)
+        newIdentifier = create_md_identifier(code = ititle, authority=i_citation)
         
         if self._dataEntityHasBeenProcessed:
@@ -133 +133 @@
     
     def _processCitation(self, ceda_observationCollection):
-        contentDict = extractContent(self._dataEntityMigration)
+        contentDict = extract_content(self._dataEntityMigration)
         if not contentDict.has_key('citation'):
             self._report(NoCitationException(self._dataEntityMigration))
@@ -141 +141 @@
 
         ci_dates = []
-        doc_date = findPublishedDate(self._dataEntityMigration)            
+        doc_date = find_published_date(self._dataEntityMigration)            
         if doc_date:
-            i_date = createDate(isoDateTimeStringToTimeDate(doc_date))           
-            ci_dates.append(createCI_Date(getCLValue(CI_DateTypeCode.cl_publication), date = i_date))
-
-        doc_date = findUpdatedDate(self._dataEntityMigration)            
+            i_date = create_date(isoDateTimeStringToTimeDate(doc_date))           
+            ci_dates.append(create_ci_date(getCLValue(CI_DateTypeCode.cl_publication), date = i_date))
+
+        doc_date = find_updated_date(self._dataEntityMigration)            
         if doc_date:
-            i_date = createDate(isoDateTimeStringToTimeDate(doc_date))                
-            ci_dates.append(createCI_Date(getCLValue(CI_DateTypeCode.cl_revision), date = i_date))
-            
-        i_citation = createCI_Citation(title = 'ceda_moles2_citation', date=ci_dates)
-        newIdentifier = createMD_Identifier(code = contentDict['citation'], authority=i_citation)
+            i_date = create_date(isoDateTimeStringToTimeDate(doc_date))                
+            ci_dates.append(create_ci_date(getCLValue(CI_DateTypeCode.cl_revision), date = i_date))
+            
+        i_citation = create_ci_citation(title = 'ceda_moles2_citation', date=ci_dates)
+        newIdentifier = create_md_identifier(code = contentDict['citation'], authority=i_citation)
 
         if self._dataEntityHasBeenProcessed:
@@ -174 +174 @@
         
         #Is a first time process?
-        if not hasMOBeenProcessed(self._dataEntityMigration):
-            docHash = getAtomDocumentHashByMO(self._dataEntityMigration)
+        if not has_mo_been_processed(self._dataEntityMigration):
+            docHash = get_atom_document_hash_by_mo(self._dataEntityMigration)
             ceda_observationCollection.publicationState = getCLValue(MM_ObservationPublicationStateValue.cl_working)
             self.epbRepo.moles3EPB.persistInstance(ceda_observationCollection)
@@ -183 +183 @@
 
         #Has to updated the hash?
-        if not self._dataEntityHasSameHash and hasMOBeenProcessed(self._dataEntityMigration):
-            docHash = getAtomDocumentHashByMO(self._dataEntityMigration)
+        if not self._dataEntityHasSameHash and has_mo_been_processed(self._dataEntityMigration):
+            docHash = get_atom_document_hash_by_mo(self._dataEntityMigration)
             self.epbRepo.migrationEPB.updateMigrationObject(self._dataEntityMigration, \
                 {'doc_hash': docHash})
@@ -192 +192 @@
             #Adds the CedaGUID
             ceda_guid = CedaGUID()
-            ceda_guid.id = calculateHash(self._dataEntityMigration.data_ent_id)
+            ceda_guid.id = calculate_hash(self._dataEntityMigration.data_ent_id)
             setattr(ceda_guid, 'ceda_observationcollection', ceda_observationCollection.id)
             self.epbRepo.moles3EPB.persistInstance(ceda_guid)
@@ -198 +198 @@
 
     def _processDOI(self, deploymentMigration, ceda_observation, deProcessor, single_deployment):        
-        doi = findDOIInMigrationDocument(deploymentMigration)                                                              
+        doi = find_doi_in_migration_document(deploymentMigration)                                                              
         if single_deployment:
             if doi is None:
-                doi = findDOIInMigrationDocument(self._dataEntityMigration)
+                doi = find_doi_in_migration_document(self._dataEntityMigration)
                     #collection_identifier = Moles3EPB.extractCollectionIdentifierByTitle(MD_CODE_MOLES2_CITATION, self.migrationSessions.molesSession)
                     #if collection_identifier.count()==1:
@@ -250 +250 @@
         
         #retrieves the associated deployment links from the data_entity
-        deploymentsLinks = findDeploymentsInDE(self._dataEntityMigration)        
+        deploymentsLinks = find_deployments_in_de(self._dataEntityMigration)        
         #retrieves the DataEntityMigration sorted by creation date
         deploymentMigrations = self.epbRepo.migrationEPB.getAllDeploymentsMigrationByDataEntitySortedByDate( \

mauRepo/MolesManager/trunk/cedaMoles/libs/migration/processor/deployment.py

@@ -31 +31 @@
 @author: Maurizio Nagni
 '''
-from cedaMoles.libs.migration.processor.commons import findMolesLineage, \
-    createMO_ResponsiblePartyInfo,\
-    DO_BADC, DO_NEODC, findAuthorsInResource, \
-    createMD_Identifier, extractSummary, extractQuality, \
-    hasMOSameHash, getAtomDocumentHashByMO, extractTitle,\
-        createCEDA_Result,\
-    createEX_GeographicBoundingBox, extractGeographicExtentInMigrationDocument, \
-    findDownloadLinksInMigrationDocument,\
-    extractContent, createCI_Citation, createCI_Date, createDate,\
-    createTM_Position, createTM_Instant, extractMolesCreationDate,\
-    createDateTime, isoDateTimeStringToTimeDate, extractMolesProviderID,\
-    DO_UKSSDC, createMO_Organization,\
-    createCI_Contact, createCI_Address, createCI_OnlineResource,\
-    createCI_Telephone, extractMolesTemporalRange,\
-    findAccessLinksInMigrationDocument,\
-    findLinksInDeployment, createMD_LegalConstraints,\
-    createDQ_Element, createDQ_ConformanceResult, findUpdatedDate,\
-    createMD_Metadata, createMO_OnlineResource, createCEDA_Review, calculateHash,\
-    createCI_ResponsibleParty, extractUpdateFrequency,\
-    findLinksInMigrationDocument, findSubTypeInDPT, extractMolesPublishedDate,\
-    createMD_Keywords, hasMOBeenProcessed, createMO_Individual,\
-    fromDateStringToPhenomenonTime, \
-    comparePhenomenonTimes, compareGeographicBoundingBoxes
+from cedaMoles.libs.migration.processor.commons import find_moles_lineage, \
+    create_mo_responsible_party_info,\
+    DO_BADC, DO_NEODC, find_authors_in_resource, \
+    create_md_identifier, extract_summary, extract_quality, \
+    has_mo_same_hash, get_atom_document_hash_by_mo, extract_title,\
+        create_ceda_result,\
+    create_ex_geographic_boundingbox, extract_ge_in_migration_doc, \
+    find_download_links_in_migration_document,\
+    extract_content, create_ci_citation, create_ci_date, create_date,\
+    create_tm_position, create_tm_instant, extract_moles_creation_date,\
+    create_datetime, isoDateTimeStringToTimeDate, extract_moles_provider_id,\
+    DO_UKSSDC, create_mo_organization,\
+    create_ci_contact, create_ci_address, create_ci_onlineresource,\
+    create_ci_telephone, extract_moles_temporal_range,\
+    find_access_links_in_migration_document,\
+    find_links_in_deployment, create_md_legal_constraints,\
+    create_dq_element, create_dq_conformance_result, find_updated_date,\
+    create_md_metadata, create_mo_online_resource, create_ceda_review, calculate_hash,\
+    create_ci_responsible_party, extract_update_frequency,\
+    find_links_in_migration_document, find_subtype_in_dpt, extract_moles_published_date,\
+    create_md_keywords, has_mo_been_processed, create_mo_individual,\
+    from_date_string_to_pt, \
+    compare_phenomenon_times, compareGeographicBoundingBoxes
 from cedaMoles.libs.epb import EPB
 from cedaMoles.libs.migration.processor.deployment_data import DeploymentDataProcessor
@@ -112 +112 @@
         self._deployment_migration = deployment_migration
         self.epbRepo = epbRepo
-        self._dataEntityHasSameHash = hasMOSameHash(self._data_entity_migration)
-        self._deploymentHasSameHash = hasMOSameHash(self._deployment_migration)
-        self._deploymentHasBeenProcessed = hasMOBeenProcessed(self._deployment_migration)
+        self._dataEntityHasSameHash = has_mo_same_hash(self._data_entity_migration)
+        self._deploymentHasSameHash = has_mo_same_hash(self._deployment_migration)
+        self._deploymentHasBeenProcessed = has_mo_been_processed(self._deployment_migration)
         self._report = []
 
@@ -139 +139 @@
         try:
             if tmp_auth['author'] == 'unknown':
-                doc_authors = findAuthorsInResource(self._data_entity_migration)
+                doc_authors = find_authors_in_resource(self._data_entity_migration)
                 tmp_auth = authors[doc_authors['authors']]
             
@@ -154 +154 @@
             for item in tmp_auth['co_author_type']:           
                 if (tmp_auth['co_author'][tmp_auth['co_author_type'].index(item)] == 'unknown'):
-                    doc_authors = findAuthorsInResource(self._data_entity_migration)
+                    doc_authors = find_authors_in_resource(self._data_entity_migration)
                     tmp_auth = authors[doc_authors['contributors']]
                     break
@@ -189 +189 @@
             
             py_date = None
-            cited_responsible = createCI_ResponsibleParty(role=getCLValue(CI_RoleCode.cl_publisher), \
+            cited_responsible = create_ci_responsible_party(role=getCLValue(CI_RoleCode.cl_publisher), \
                                                               organizationName='NERC - British Atmospheric Data Centre')
             if doi.upper() == '10.5285/E8F43A51-0198-4323-A926-FE69225D57DD':
@@ -201 +201 @@
                 
             if py_date:   
-                dt = createDate(py_date)
-                ci_date = createCI_Date(getCLValue(CI_DateTypeCode.cl_publication), date = dt)
-                i_authority = createCI_Citation("DOI", date = ci_date)
-                identifier = createMD_Identifier(code = doi, authority=i_authority)
+                dt = create_date(py_date)
+                ci_date = create_ci_date(getCLValue(CI_DateTypeCode.cl_publication), date = dt)
+                i_authority = create_ci_citation("DOI", date = ci_date)
+                identifier = create_md_identifier(code = doi, authority=i_authority)
                 self.epbRepo.moles3EPB.updateCedaObject(observation, {'identifier': identifier})
                 DeploymentProcessor.log.info("DOI: %s" % (doi))                                  
@@ -212 +212 @@
             return
         
-        provider_id = extractMolesProviderID(self._deployment_migration)
+        provider_id = extract_moles_provider_id(self._deployment_migration)
         i_keywords = []
         if provider_id == DO_BADC:
@@ -221 +221 @@
             #Is a first time process?
             if not self._deploymentHasBeenProcessed: 
-                ceda_observation.keywords.append(createMD_Keywords(i_keywords))
+                ceda_observation.keywords.append(create_md_keywords(i_keywords))
             else:
                 ceda_observation.keywords.keyword = i_keywords          
@@ -229 +229 @@
             return
         
-        data_lineage = findMolesLineage(self._data_entity_migration)
+        data_lineage = find_moles_lineage(self._data_entity_migration)
         if data_lineage is None:
             raise NoDataLineage(self._data_entity_migration)
@@ -241 +241 @@
 
         i_sources = []                
-        download = findDownloadLinksInMigrationDocument(self._deployment_migration)
+        download = find_download_links_in_migration_document(self._deployment_migration)
         content = None
         if len(download) == 0:
-            download = findDownloadLinksInMigrationDocument(self._data_entity_migration)
-            content = extractContent(self._data_entity_migration)
+            download = find_download_links_in_migration_document(self._data_entity_migration)
+            content = extract_content(self._data_entity_migration)
         else:
-            content = extractContent(self._deployment_migration)
+            content = extract_content(self._deployment_migration)
         for dwn in download:
             int_description = None
@@ -256 +256 @@
             if dwn['href'].startswith('http://badc.nerc.ac.uk/browse') or dwn['href'].startswith('http://neodc.nerc.ac.uk/browse'):
                 int_description = "download directly from archive"    
-            i_sources.append(createMO_OnlineResource(linkage = dwn['href'], name = dwn['title'], \
+            i_sources.append(create_mo_online_resource(linkage = dwn['href'], name = dwn['title'], \
                                                    function = getCLValue(CI_OnLineFunctionCode.cl_download), \
                                                    description = int_description, applicationProfile = int_applicationProfile))
@@ -275 +275 @@
 
         if not self._deploymentHasBeenProcessed:                     
-            observation.result = createCEDA_Result(i_category, i_logical_path, source = i_sources)
+            observation.result = create_ceda_result(i_category, i_logical_path, source = i_sources)
             return 
         
@@ -290 +290 @@
             return
            
-        provider_id = extractMolesProviderID(self._deployment_migration)
+        provider_id = extract_moles_provider_id(self._deployment_migration)
         party = None
         if provider_id == DO_BADC:
             i_linkage = 'http://badc.rl.ac.uk'
-            i_onlineResources = createCI_OnlineResource(linkage = i_linkage, name = 'British Atmospheric Data Centre Website')
-            i_address = createCI_Address(deliveryPoint = ['British Atmospheric Data Centre, STFC Rutherford Appleton Laboratory'], \
+            i_onlineResources = create_ci_onlineresource(linkage = i_linkage, name = 'British Atmospheric Data Centre Website')
+            i_address = create_ci_address(deliveryPoint = ['British Atmospheric Data Centre, STFC Rutherford Appleton Laboratory'], \
                                          electronicMailAddress=['badc@rl.ac.uk'], postalCode='OX11 0QX', country='UK', city='Harwell Oxford')                                   
-            i_phone = createCI_Telephone(voice=['+44(0)1235 446432'])                                  
-            contact = createCI_Contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
-            party = createMO_Organization(name = "NERC - British Atmospheric Data Centre", contactInfo = [contact])
+            i_phone = create_ci_telephone(voice=['+44(0)1235 446432'])                                  
+            contact = create_ci_contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
+            party = create_mo_organization(name = "NERC - British Atmospheric Data Centre", contactInfo = [contact])
         elif provider_id == DO_NEODC:
             i_linkage = 'http://www.neodc.rl.ac.uk'
-            i_onlineResources = createCI_OnlineResource(linkage = i_linkage, name = 'NERC Earth Observation Data Centre website')
-            i_address = createCI_Address(deliveryPoint = ['NERC - Earth Observation Data Centre, STFC Rutherford Appleton Laboratory'], \
+            i_onlineResources = create_ci_onlineresource(linkage = i_linkage, name = 'NERC Earth Observation Data Centre website')
+            i_address = create_ci_address(deliveryPoint = ['NERC - Earth Observation Data Centre, STFC Rutherford Appleton Laboratory'], \
                                          electronicMailAddress=['neodc@rl.ac.uk'], postalCode='OX11 0QX', country='UK', city='Harwell Oxford')                                   
-            i_phone = createCI_Telephone(voice=['+44(0)1235 446432'])                                 
-            contact = createCI_Contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
-            party = createMO_Organization(name = 'NERC - Earth Observation Data Centre', contactInfo = [contact])
+            i_phone = create_ci_telephone(voice=['+44(0)1235 446432'])                                 
+            contact = create_ci_contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
+            party = create_mo_organization(name = 'NERC - Earth Observation Data Centre', contactInfo = [contact])
         elif provider_id == DO_UKSSDC:
             i_linkage = 'http://www.ukssdc.rl.ac.uk'
-            i_onlineResources = createCI_OnlineResource(linkage = i_linkage, name = 'UK Solar System Data Centre website')
-            i_address = createCI_Address(deliveryPoint = ['UK Solar System Data Centre, STFC Rutherford Appleton Laboratory'], \
+            i_onlineResources = create_ci_onlineresource(linkage = i_linkage, name = 'UK Solar System Data Centre website')
+            i_address = create_ci_address(deliveryPoint = ['UK Solar System Data Centre, STFC Rutherford Appleton Laboratory'], \
                                          electronicMailAddress=['support@rl.ac.uk'], postalCode='OX11 0QX', country='UK', city='Harwell Oxford')                                   
-            i_phone = createCI_Telephone(voice=['+44(0)1235 445173'])                                 
-            contact = createCI_Contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
-            party = createMO_Organization(name = 'NERC - UK Solar System Data Centre', contactInfo = [contact])
+            i_phone = create_ci_telephone(voice=['+44(0)1235 445173'])                                 
+            contact = create_ci_contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
+            party = create_mo_organization(name = 'NERC - UK Solar System Data Centre', contactInfo = [contact])
         
         if party and not self._deploymentHasBeenProcessed:
             newrp = []
-            newrp.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_publisher), [party]))
-            newrp.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_custodian), deepcopy([party])))
-            newrp.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_distributor), deepcopy([party])))
-            newrp.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_pointofcontact), deepcopy([party])))
-            newrp.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_metadataowner), deepcopy([party])))
-            newrp.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_curator), deepcopy([party])))
+            newrp.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_publisher), [party]))
+            newrp.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_custodian), deepcopy([party])))
+            newrp.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_distributor), deepcopy([party])))
+            newrp.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_pointofcontact), deepcopy([party])))
+            newrp.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_metadataowner), deepcopy([party])))
+            newrp.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_curator), deepcopy([party])))
             self.epbRepo.moles3EPB.updateCedaObject(observation, {'relatedParty': newrp})            
             return        
@@ -333 +333 @@
             return
                 
-        doc_quality = extractQuality(self._data_entity_migration)
-        doc_date = findUpdatedDate(self._data_entity_migration)
+        doc_quality = extract_quality(self._data_entity_migration)
+        doc_date = find_updated_date(self._data_entity_migration)
         ci_dates = []            
         if doc_date:
-            i_date = createDate(isoDateTimeStringToTimeDate(doc_date))                
-            ci_dates.append(createCI_Date(getCLValue(CI_DateTypeCode.cl_revision), date = i_date))            
+            i_date = create_date(isoDateTimeStringToTimeDate(doc_date))                
+            ci_dates.append(create_ci_date(getCLValue(CI_DateTypeCode.cl_revision), date = i_date))            
         else:
-            i_date = createDate(isoDateTimeStringToTimeDate(datetime.datetime.now()))
-            ci_dates.append(createCI_Date(getCLValue(CI_DateTypeCode.cl_creation), date = i_date))
-
-        i_specification = createCI_Citation(title = "CEDA Data Quality Statement", date=ci_dates)
-        i_dq_result = createDQ_ConformanceResult(doc_quality, True, i_specification)
-        i_quality_element = createDQ_Element(i_dq_result)
+            i_date = create_date(isoDateTimeStringToTimeDate(datetime.datetime.now()))
+            ci_dates.append(create_ci_date(getCLValue(CI_DateTypeCode.cl_creation), date = i_date))
+
+        i_specification = create_ci_citation(title = "CEDA Data Quality Statement", date=ci_dates)
+        i_dq_result = create_dq_conformance_result(doc_quality, True, i_specification)
+        i_quality_element = create_dq_element(i_dq_result)
         
         if not self._deploymentHasBeenProcessed:     
@@ -356 +356 @@
             return
         
-        description = extractSummary(self._deployment_migration)
+        description = extract_summary(self._deployment_migration)
         if description is None:
-            description = extractSummary(self._data_entity_migration)
+            description = extract_summary(self._data_entity_migration)
             
         if description:
@@ -367 +367 @@
             return
                      
-        doc_title = extractTitle(self._deployment_migration)
+        doc_title = extract_title(self._deployment_migration)
         if doc_title is None:
-            doc_title = extractTitle(self._data_entity_migration)
+            doc_title = extract_title(self._data_entity_migration)
         
         if doc_title.startswith('deployment_') or doc_title.startswith('Deployment_'):
-            links = findLinksInMigrationDocument(self._deployment_migration)
+            links = find_links_in_migration_document(self._deployment_migration)
             dptList = links['DPT']
             if links.has_key('DPT'):
@@ -382 +382 @@
                         doc_title += ' and ' + dptList[-1]
                                                         
-            links = findLinksInDeployment(self._deployment_migration)
+            links = find_links_in_deployment(self._deployment_migration)
             if links.has_key('OBS'):
                 obsList = []
                 for obs in links['OBS']:
                     observationStation = self.epbRepo.migrationEPB.getDeploymentDataMigrationByName(self._deployment_migration, obs + '.atom')
-                    obsList.append((extractTitle(observationStation), findSubTypeInDPT(observationStation)))
+                    obsList.append((extract_title(observationStation), find_subtype_in_dpt(observationStation)))
                 
                 if obsList[0][1] in ['stationary platform' ,'moving platform', 'ship','aircraft','satellite','computer']:
@@ -404 +404 @@
                     activity = self.epbRepo.migrationEPB.getDeploymentDataMigrationByName(self._deployment_migration, link + '.atom')                    
      
-                    projSubType = findSubTypeInDPT(activity)
-                    doc_title += ' for the ' + extractTitle(activity)
+                    projSubType = find_subtype_in_dpt(activity)
+                    doc_title += ' for the ' + extract_title(activity)
                     if projSubType[0:14] == 'dgActivityData':
                         doc_title += ' ' + projSubType[14:]
@@ -413 +413 @@
             if doc_title[0:10] != 'Data from' :
                 doc_title = "Data from " + doc_title            
-        auth = createCI_Citation(title = 'ceda_title')                  
-        identifier = createMD_Identifier(code = doc_title, authority = auth)
+        auth = create_ci_citation(title = 'ceda_title')                  
+        identifier = create_md_identifier(code = doc_title, authority = auth)
         
         if not self._deploymentHasBeenProcessed: 
@@ -425 +425 @@
             return  
         
-        ge = extractGeographicExtentInMigrationDocument(self._deployment_migration)        
+        ge = extract_ge_in_migration_doc(self._deployment_migration)        
         if ge is None:
-            ge = extractGeographicExtentInMigrationDocument(self._data_entity_migration)
+            ge = extract_ge_in_migration_doc(self._data_entity_migration)
         
         if ge is None:
@@ -433 +433 @@
             self._report.append(NoGeographicalExtensionException(self._data_entity_migration))
         
-        geographicExtent = createEX_GeographicBoundingBox(ge['east'], ge['north'], ge['west'], ge['south'])
+        geographicExtent = create_ex_geographic_boundingbox(ge['east'], ge['north'], ge['west'], ge['south'])
 
         if len(observation.geographicExtent) == 0 or \
@@ -445 +445 @@
             return  
         
-        creation_date = extractMolesPublishedDate(self._deployment_migration)
+        creation_date = extract_moles_published_date(self._deployment_migration)
         if creation_date is None:
-            creation_date = extractMolesCreationDate(self._deployment_migration)
+            creation_date = extract_moles_creation_date(self._deployment_migration)
         py_datetime = isoDateTimeStringToTimeDate(creation_date)
-        date_time = createDateTime(py_datetime)    
-        tm_position = createTM_Position(dateTime8601 = date_time)
+        date_time = create_datetime(py_datetime)    
+        tm_position = create_tm_position(dateTime8601 = date_time)
         
         if not self._deploymentHasBeenProcessed: 
-            observation.resultTime = createTM_Instant(tm_position)
+            observation.resultTime = create_tm_instant(tm_position)
             return        
         #Still have to update observation.geographicExtent
@@ -461 +461 @@
             return  
               
-        doc_phenomenon_time = extractMolesTemporalRange(self._deployment_migration) 
-        pt = fromDateStringToPhenomenonTime(doc_phenomenon_time)    
-        
-        if not self._deploymentHasBeenProcessed or not comparePhenomenonTimes(pt,observation.phenomenonTime):
+        doc_phenomenon_time = extract_moles_temporal_range(self._deployment_migration) 
+        pt = from_date_string_to_pt(doc_phenomenon_time)    
+        
+        if not self._deploymentHasBeenProcessed or not compare_phenomenon_times(pt,observation.phenomenonTime):
             self.epbRepo.moles3EPB.updateCedaObject(observation, {'phenomenonTime': pt})
         #Now update phenomenonTime but has to remove the previous phenomenonTime                
@@ -472 +472 @@
             return 
         
-        access_link = findAccessLinksInMigrationDocument(self._deployment_migration)
-        dwn_link = findDownloadLinksInMigrationDocument(self._deployment_migration)
+        access_link = find_access_links_in_migration_document(self._deployment_migration)
+        dwn_link = find_download_links_in_migration_document(self._deployment_migration)
         if len(access_link) == 0:
-            access_link = findAccessLinksInMigrationDocument(self._data_entity_migration) 
+            access_link = find_access_links_in_migration_document(self._data_entity_migration) 
 
         i_accessConstraints = []
@@ -483 +483 @@
         if len(access_link) == 0:
             if len(dwn_link) == 0:
-                dwn_link = findDownloadLinksInMigrationDocument(self._data_entity_migration)
+                dwn_link = find_download_links_in_migration_document(self._data_entity_migration)
                 if dwn_link and len(dwn_link) == 1:                
                     i_use_limitation.append("These data are open access and available through %s." % (dwn_link[0]['href']) )
                     #i_accessConstraints.append(MD_RestrictionCode.cl_)
-                    observation.permission = createMD_LegalConstraints(useLimitation = i_use_limitation, accessConstrains = i_accessConstraints)
+                    observation.permission = create_md_legal_constraints(useLimitation = i_use_limitation, accessConstrains = i_accessConstraints)
         else:
             if access_link and len(access_link) == 1:
                 i_use_limitation.append("Access to these data is restricted. To obtain access please apply for access at: %s" % (access_link[0]['href']))
                 i_accessConstraints.append(getCLValue(MD_RestrictionCode.cl_restricted))
-                observation.permission = createMD_LegalConstraints(useLimitation = i_use_limitation, accessConstrains = i_accessConstraints)
+                observation.permission = create_md_legal_constraints(useLimitation = i_use_limitation, accessConstrains = i_accessConstraints)
                 
         if not self._deploymentHasBeenProcessed:
@@ -499 +499 @@
                                     
         '''                                
-        contentDict = extractContent(self._deployment_migration)
+        contentDict = extract_content(self._deployment_migration)
         if not contentDict.has_key('access-restricted'):
-            contentDict = extractContent(self._data_entity_migration)
+            contentDict = extract_content(self._data_entity_migration)
         '''            
 
@@ -510 +510 @@
         i_code = 'http://badc.nerc.ac.uk/view/%s__ATOM__%s' % (self._deployment_migration.doc_owner, self._deployment_migration.doc_name)
         i_code = i_code.replace('.atom', '')
-        #i_code = buildExistDocPath(self._deployment_migration.doc_status, DT_DEPLOYMENTS, self._deployment_migration.doc_owner, self._deployment_migration.doc_name)
-        i_authority = createCI_Citation('moles2url')
-        identifier = createMD_Identifier(code = i_code, authority = i_authority)
+        i_authority = create_ci_citation('moles2url')
+        identifier = create_md_identifier(code = i_code, authority = i_authority)
         if not self._deploymentHasBeenProcessed:             
             ceda_observation.identifier.append(identifier)
@@ -521 +520 @@
             return
                
-        i_party = createMO_Individual(name = 'Graham Parton')
-        i_reviewer = createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_processor), [i_party])
+        i_party = create_mo_individual(name = 'Graham Parton')
+        i_reviewer = create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_processor), [i_party])
         ceda_observation.metadataManagement.append( \
-            createCEDA_Review(reviewer=i_reviewer, reviewFrequency=getCLValue(CEDA_ReviewFrequencyValue.cl_yearly), \
+            create_ceda_review(reviewer=i_reviewer, reviewFrequency=getCLValue(CEDA_ReviewFrequencyValue.cl_yearly), \
                               reviewStatus=getCLValue(CEDA_ReviewStatusValue.cl_required)))  
 
@@ -531 +530 @@
             return
         
-        i_date_stamp = createDate(datetime.datetime.now())
+        i_date_stamp = create_date(datetime.datetime.now())
         #i_contact = createCI_Citation("", date = i_date_stamp)
-        i_contact = createCI_ResponsibleParty(getCLValue(CI_RoleCode.cl_user))
-        ceda_observation.metadata = createMD_Metadata(date_stamp=i_date_stamp, contact = [i_contact], language = "English")
+        i_contact = create_ci_responsible_party(getCLValue(CI_RoleCode.cl_user))
+        ceda_observation.metadata = create_md_metadata(date_stamp=i_date_stamp, contact = [i_contact], language = "English")
                         
     def _processResultAccumulation(self, ceda_observation):  
@@ -540 +539 @@
             return                      
 
-            updateFrequency = extractUpdateFrequency(self._data_entity_migration)
+            updateFrequency = extract_update_frequency(self._data_entity_migration)
             if updateFrequency:
                 resultAccumulation = MD_MaintenanceFrequencyCode.from_string(updateFrequency)
@@ -557 +556 @@
         
         whereAreAuthors = self._deployment_migration        
-        doc_authors = findAuthorsInResource(self._deployment_migration)        
+        doc_authors = find_authors_in_resource(self._deployment_migration)        
         if doc_authors['authors'] in [DO_BADC, DO_NEODC]:
-            doc_authors = findAuthorsInResource(self._data_entity_migration)
+            doc_authors = find_authors_in_resource(self._data_entity_migration)
             whereAreAuthors = self._data_entity_migration 
                 
@@ -569 +568 @@
 
             if len(ret['ind']) > 0:
-                i_party = createMO_Individual(name = ret['ind'][0])
-                observation.relatedParty.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_author), [i_party]))                 
+                i_party = create_mo_individual(name = ret['ind'][0])
+                observation.relatedParty.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_author), [i_party]))                 
             if len(ret['org']) > 0:
-                i_party = createMO_Organization(name = ret['org'][0])
-                observation.relatedParty.append(createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_author), [i_party]))
+                i_party = create_mo_organization(name = ret['org'][0])
+                observation.relatedParty.append(create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_author), [i_party]))
             
             if len(ret['ind']) > 1:
@@ -597 +596 @@
         i_party = []
         for nm in ind_names:
-            i_party.append(createMO_Individual(name = nm))
+            i_party.append(create_mo_individual(name = nm))
                 
         for nm in org_names:
-            i_party.append(createMO_Organization(name = nm))
+            i_party.append(create_mo_organization(name = nm))
             
         if i_party:
             if not self._deploymentHasBeenProcessed:
-                rp = createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_coinvestigator), i_party)
+                rp = create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_coinvestigator), i_party)
                 self.epbRepo.moles3EPB.updateCedaObject(observation, {'relatedParty': rp})
                 return
@@ -629 +628 @@
         
         #Is a first time process?
-        if not hasMOBeenProcessed(self._deployment_migration):
+        if not has_mo_been_processed(self._deployment_migration):
             ceda_observation.publicationState = getCLValue(MM_ObservationPublicationStateValue.cl_working)          
-            docHash = getAtomDocumentHashByMO(self._data_entity_migration)
+            docHash = get_atom_document_hash_by_mo(self._data_entity_migration)
             self.epbRepo.moles3EPB.persistInstance(ceda_observation)        
             self.epbRepo.migrationEPB.updateMigrationObject(self._deployment_migration, \
@@ -640 +639 @@
         if self.epbRepo.moles3EPB.retrieveGUIDFromInstance(ceda_observation) is None:       
             ceda_guid = CedaGUID()
-            ceda_guid.id = calculateHash(self._deployment_migration.depl_id)
+            ceda_guid.id = calculate_hash(self._deployment_migration.depl_id)
             ceda_guid.ceda_observation = ceda_observation.id
             self.epbRepo.moles3EPB.persistInstance(ceda_guid)

mauRepo/MolesManager/trunk/cedaMoles/libs/migration/processor/deployment_data.py

@@ -31 +31 @@
 @author: Maurizio Nagni
 '''
-from cedaMoles.libs.migration.processor.commons import findSubTypeInDPT,\
-    createCEDA_Processing, createCEDA_Instrument, createCEDA_Project,\
-    findSummary, findDocumentationInMigrationDocument, createCI_Citation,\
-    createMO_OnlineResource, findLinksInDeployment, hasMOBeenProcessed,\
-    getAtomDocumentHashByMO, calculateHash, hasMOSameHash
+from cedaMoles.libs.migration.processor.commons import find_subtype_in_dpt,\
+    create_ceda_processing, create_ceda_instrument, create_ceda_project,\
+    find_summary, find_documentation_in_migration_document, create_ci_citation,\
+    create_mo_online_resource, find_links_in_deployment, has_mo_been_processed,\
+    get_atom_document_hash_by_mo, calculate_hash, has_mo_same_hash
 from ea_model.moles3_4.utilities.ceda_publicationstatevalue import CEDA_PublicationStateValue
 from cedaMoles.MolesManager.codelist import getCLValue
@@ -54 +54 @@
         self._deploymentMigration = deploymentMigration
         self.epbRepo = epbRepo        
-        self._links = findLinksInDeployment(self._deploymentMigration)
+        self._links = find_links_in_deployment(self._deploymentMigration)
         
     def _commitDeploymentMigration(self, associateWithCedaObservation, dataProductionTool, dataProductionToolField):
@@ -61 +61 @@
                                    
     def _createProject(self, activity):        
-        i_abstract = findSummary(activity)
-        doc_link = findDocumentationInMigrationDocument(activity)
+        i_abstract = find_summary(activity)
+        doc_link = find_documentation_in_migration_document(activity)
         i_documentation = None
         i_resource = None
         if doc_link and len(doc_link) == 1:
-            i_documentation = createCI_Citation("Documentation resource")
-            i_resource = createMO_OnlineResource(doc_link[0]['href'])
-        project = createCEDA_Project(abstract=i_abstract, publication_state=getCLValue(CEDA_PublicationStateValue.cl_working), \
+            i_documentation = create_ci_citation("Documentation resource")
+            i_resource = create_mo_online_resource(doc_link[0]['href'])
+        project = create_ceda_project(abstract=i_abstract, publication_state=getCLValue(CEDA_PublicationStateValue.cl_working), \
                                      documentation=i_documentation, project_resource=i_resource)
         self._commitDeploymentMigration(project, activity, 'ceda_project_id')
@@ -78 +78 @@
             for link in self._links['ACTIVITY']:
                 activity = self.epbRepo.migrationEPB.getDeploymentDataMigrationByName(self._deploymentMigration, link + '.atom')
-                deploymentDataHasSameHash = hasMOSameHash(activity)    
-                deploymentDataHasBeenProcessed = hasMOBeenProcessed(activity)               
+                deploymentDataHasSameHash = has_mo_same_hash(activity)    
+                deploymentDataHasBeenProcessed = has_mo_been_processed(activity)               
                 try :
                     if activity.ceda_project_id is not None:
@@ -93 +93 @@
                 #Is a first time process?
                 if not deploymentDataHasBeenProcessed:
-                    docHash = getAtomDocumentHashByMO(activity)
+                    docHash = get_atom_document_hash_by_mo(activity)
                     self.epbRepo.migrationEPB.updateMigrationObject(activity, \
                         {'ceda_project_id': project.id, \
@@ -100 +100 @@
                 #Has to updated the hash?
                 if not deploymentDataHasSameHash and deploymentDataHasBeenProcessed:
-                    docHash = getAtomDocumentHashByMO(activity)
+                    docHash = get_atom_document_hash_by_mo(activity)
                     self.epbRepo.migrationEPB.updateMigrationObject(activity, \
                         {'doc_hash': docHash})
@@ -108 +108 @@
                     #Adds the CedaGUID
                     ceda_guid = CedaGUID()
-                    ceda_guid.id = calculateHash(activity.deployment_data_id)
+                    ceda_guid.id = calculate_hash(activity.deployment_data_id)
                     setattr(ceda_guid, 'ceda_project', project.id)
                     self.epbRepo.moles3EPB.persistInstance(ceda_guid)
@@ -123 +123 @@
             
             #has the document changed?            
-            #if hasMOSameHash(dataProductionTool):
-            #    dataProductionTool.doc_hash = getAtomDocumentHashByMO(self._deploymentMigration)
+            #if has_mo_same_hash(dataProductionTool):
+            #    dataProductionTool.doc_hash = get_atom_document_hash_by_mo(self._deploymentMigration)
             #    self._migrationSessions.migrationSession.commit()
             #    continue
             
-            subType = findSubTypeInDPT(dataProductionTool)
+            subType = find_subtype_in_dpt(dataProductionTool)
             
             if subType == 'model':
                 #MigrationEPB.loadAttributes(dataProductionTool, 'ceda_processing_id')
                 if dataProductionTool.ceda_processing_id is None:
-                    associateWithCedaObservation = createCEDA_Processing()
+                    associateWithCedaObservation = create_ceda_processing()
                     self._commitDeploymentMigration(associateWithCedaObservation, dataProductionTool, 'ceda_processing_id')
                     if not (hasCedaComposite or hasCedaProcessing):
@@ -145 +145 @@
                 #MigrationEPB.loadAttributes(dataProductionTool, 'ceda_instrument_id')
                 if dataProductionTool.ceda_instrument_id is None:
-                    associateWithCedaObservation = createCEDA_Instrument()
+                    associateWithCedaObservation = create_ceda_instrument()
                     self._commitDeploymentMigration(associateWithCedaObservation, dataProductionTool, 'ceda_instrument_id')
                 else:
@@ -157 +157 @@
  
             #has the document changed?            
-            #if hasMOSameHash(observationStation):
-            #    observationStation.doc_hash = getAtomDocumentHashByMO(self._deploymentMigration)
+            #if has_mo_same_hash(observationStation):
+            #    observationStation.doc_hash = get_atom_document_hash_by_mo(self._deploymentMigration)
             #    self._migrationSessions.migrationSession.commit()
             #    continue                       
             
-            subType = findSubTypeInDPT(observationStation)
+            subType = find_subtype_in_dpt(observationStation)
             if subType == 'satellite':
                 #MigrationEPB.loadAttributes(dataProductionTool, 'ceda_compositeprocess_id')                
                 if dataProductionTool.ceda_compositeprocess_id is None:
-                    associateWithCedaObservation = createCEDA_Processing()
+                    associateWithCedaObservation = create_ceda_processing()
                     self._commitDeploymentMigration(associateWithCedaObservation, dataProductionTool, 'ceda_compositeprocess_id')   
                     if not hasCedaComposite:
@@ -180 +180 @@
                     pass
                     '''
-                    associateWithCedaObservation = createCEDA_Acquisition()
+                    associateWithCedaObservation = create_ceda_acquisition()
                     self._commitDeploymentMigration(associateWithCedaObservation, dataProductionTool, 'ceda_acquisition_id')
                     '''                

mauRepo/MolesManager/trunk/cedaMoles/libs/migration/processor/loadResources.py

@@ -31 +31 @@
 @author: Maurizio Nagni
 '''
-from cedaMoles.libs.migration.processor.commons import DOC_STATUS, getCollectionRefs,\
-    findMolesCreationDate, findID, stringToTimestamp, buildExistTypePath,\
-    buildExistDocPath, DT_DATA_ENTITIES, DT_DEPLOYMENTS, DT_DEPLOYMENT_DATA,\
-    getOwnerRefs, getAtomDocumentAsElementtree
+from cedaMoles.libs.migration.processor.commons import DOC_STATUS, get_collection_refs,\
+    find_moles_creation_date, find_id, stringToTimestamp, build_exist_type_path,\
+    build_exist_doc_path, DT_DATA_ENTITIES, DT_DEPLOYMENTS, DT_DEPLOYMENT_DATA,\
+    get_owner_refs, get_atom_document_as_elementtree
 from cedaMoles.libs.migration.exception.exceptions import NoCreationDate, NoDocumentID
 from cedaMoles.libs.migration.db.classes import DeploymentDataMigration,\
@@ -83 +83 @@
     def _loadCollections(self, docStatus, docType, migrationClass):
         ex = []
-        refs = getCollectionRefs(buildExistTypePath(docStatus, docType))            
+        refs = get_collection_refs(build_exist_type_path(docStatus, docType))            
         for ref in refs:
             docOwner = ref.get('name')  
@@ -94 +94 @@
     def _loadMigrationDocs(self, docStatus, docOwner, docType, migrationClass):
         ex = []
-        refs = getOwnerRefs(docStatus, docType, docOwner)                    
+        refs = get_owner_refs(docStatus, docType, docOwner)                    
         for ref in refs:
             docName = ref.get('name')
@@ -101 +101 @@
             except Exception as e:
                 if hasattr(e, 'value'):
-                    e.value = buildExistDocPath(docStatus, docType, docOwner, docName)
+                    e.value = build_exist_doc_path(docStatus, docType, docOwner, docName)
                 ex.append(e)
         return ex
@@ -115 +115 @@
          
         #The docHash has to be set/check when the document is processed!  
-        #docHash = getAtomDocumentHash(docStatus, docType, docOwner, docName)
-        xmlDocument = getAtomDocumentAsElementtree(docStatus, docType, docOwner, docName)
-        doc_id = findID(xmlDocument)
+        xmlDocument = get_atom_document_as_elementtree(docStatus, docType, docOwner, docName)
+        doc_id = find_id(xmlDocument)
          
         #The document has been already classified
@@ -130 +129 @@
 
     def _extractID(self, xmlDocument):
-        doc_id = findID(xmlDocument) 
+        doc_id = find_id(xmlDocument) 
         if doc_id is None:
             raise NoDocumentID(doc_id)
@@ -136 +135 @@
 
     def _extractCreationDate(self, xmlDocument):
-        creationDate = findMolesCreationDate(xmlDocument)            
+        creationDate = find_moles_creation_date(xmlDocument)            
         if creationDate is None:
             raise NoCreationDate(creationDate)

mauRepo/MolesManager/trunk/cedaMoles/tests/cedamoles/mo/responsiblePartyInfo.py

@@ -31 +31 @@
 @author: mnagni
 '''
-from cedaMoles.libs.migration.processor.commons import createMO_ResponsiblePartyInfo,\
-    createCI_OnlineResource, createCI_Address, createCI_Telephone,\
-    createCI_Contact, createMO_Organization
+from cedaMoles.libs.migration.processor.commons import create_mo_responsible_party_info,\
+    create_ci_onlineresource, create_ci_address, create_ci_telephone,\
+    create_ci_contact, create_mo_organization
 from cedaMoles.MolesManager.codelist import getCLValue, MM_RoleValue
 from ea_model.moles3_4.utilities.mo_organisation import MO_Organisation
@@ -43 +43 @@
     parties = []
     i_linkage = 'http://badc.rl.ac.uk'
-    i_onlineResources = createCI_OnlineResource(linkage = i_linkage, name = 'British Atmospheric Data Centre Website')
-    i_address = createCI_Address(deliveryPoint = ['British Atmospheric Data Centre, STFC Rutherford Appleton Laboratory'], \
+    i_onlineResources = create_ci_onlineresource(linkage = i_linkage, name = 'British Atmospheric Data Centre Website')
+    i_address = create_ci_address(deliveryPoint = ['British Atmospheric Data Centre, STFC Rutherford Appleton Laboratory'], \
                                  electronicMailAddress=['badc@rl.ac.uk'], postalCode='OX11 0QX', country='UK', city='Harwell Oxford')                                   
-    i_phone = createCI_Telephone(voice=['+44(0)1235 446432'])                                  
-    contact = createCI_Contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                        
-    parties.append(createMO_Organization(name = "NERC - British Atmospheric Data Centre", contactInfo = [contact]))
+    i_phone = create_ci_telephone(voice=['+44(0)1235 446432'])                                  
+    contact = create_ci_contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                        
+    parties.append(create_mo_organization(name = "NERC - British Atmospheric Data Centre", contactInfo = [contact]))
     
     i_linkage = 'http://www.neodc.rl.ac.uk'
-    i_onlineResources = createCI_OnlineResource(linkage = i_linkage, name = 'NERC Earth Observation Data Centre website')
-    i_address = createCI_Address(deliveryPoint = ['NERC - Earth Observation Data Centre, STFC Rutherford Appleton Laboratory'], \
+    i_onlineResources = create_ci_onlineresource(linkage = i_linkage, name = 'NERC Earth Observation Data Centre website')
+    i_address = create_ci_address(deliveryPoint = ['NERC - Earth Observation Data Centre, STFC Rutherford Appleton Laboratory'], \
                                  electronicMailAddress=['neodc@rl.ac.uk'], postalCode='OX11 0QX', country='UK', city='Harwell Oxford')                                   
-    i_phone = createCI_Telephone(voice=['+44(0)1235 446432'])                                 
-    contact = createCI_Contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                        
-    parties.append(createMO_Organization(name = 'NERC - Earth Observation Data Centre', contactInfo = [contact]))       
-    return createMO_ResponsiblePartyInfo(getCLValue(MM_RoleValue.cl_publisher), parties)    
+    i_phone = create_ci_telephone(voice=['+44(0)1235 446432'])                                 
+    contact = create_ci_contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                        
+    parties.append(create_mo_organization(name = 'NERC - Earth Observation Data Centre', contactInfo = [contact]))       
+    return create_mo_responsible_party_info(getCLValue(MM_RoleValue.cl_publisher), parties)    
 
 class ResponsiblePartyInfoTest(CedaMolesTest):

mauRepo/MolesManager/trunk/cedaMoles/tests/migration/commontest.py

@@ -6 +6 @@
 from unittest import TestCase
 from cedaMoles.libs.migration.processor.commons import isoDateTimeStringToTimeDate,\
-    fromDateStringToPhenomenonTime, fromPhenomenonTimeToString,\
-    comparePhenomenonTimes
+    from_date_string_to_pt, from_pt_to_string,\
+    compare_phenomenon_times
 
 
@@ -25 +25 @@
     def testFromDateStringToPhenomenonTime(self):
         temporalRange = '2002-07-22/2011-08-06'
-        pt = fromDateStringToPhenomenonTime(temporalRange)
+        pt = from_date_string_to_pt(temporalRange)
         print pt
         
     def testFromPhenomenonTimeToString(self):
         temporalRange = '2002-07-22/2011-08-06'
-        pt = fromDateStringToPhenomenonTime(temporalRange)
-        ptString = fromPhenomenonTimeToString(pt)
+        pt = from_date_string_to_pt(temporalRange)
+        ptString = from_pt_to_string(pt)
         startDate, endDate = temporalRange.split('/')        
         self.assertTrue(startDate == ptString[0], "Error")        
@@ -37 +37 @@
         
         temporalRange = '2002-07-22'
-        pt = fromDateStringToPhenomenonTime(temporalRange)
-        ptString = fromPhenomenonTimeToString(pt)
+        pt = from_date_string_to_pt(temporalRange)
+        ptString = from_pt_to_string(pt)
         startDate, endDate = temporalRange, None        
         self.assertTrue(startDate == ptString[0], "Error")        
@@ -44 +44 @@
         
     def testComparePhenomenonTimes(self):
-        p1 = fromDateStringToPhenomenonTime('2002-07-22/2011-08-06')
-        p2 = fromDateStringToPhenomenonTime('2002-07-22/2011-08-06')
-        self.assertTrue(comparePhenomenonTimes(p1,p2), "Error")
+        p1 = from_date_string_to_pt('2002-07-22/2011-08-06')
+        p2 = from_date_string_to_pt('2002-07-22/2011-08-06')
+        self.assertTrue(compare_phenomenon_times(p1,p2), "Error")
         
-        p2 = fromDateStringToPhenomenonTime('2002-07-22/2011-08-05')
-        self.assertFalse(comparePhenomenonTimes(p1,p2), "Error")
+        p2 = from_date_string_to_pt('2002-07-22/2011-08-05')
+        self.assertFalse(compare_phenomenon_times(p1,p2), "Error")
         
-        p2 = fromDateStringToPhenomenonTime('2002-07-22')
-        self.assertFalse(comparePhenomenonTimes(p1,p2), "Error")
+        p2 = from_date_string_to_pt('2002-07-22')
+        self.assertFalse(compare_phenomenon_times(p1,p2), "Error")
         

mauRepo/MolesManager/trunk/cedaMoles/tests/migration/loadresource.py

@@ -7 +7 @@
 from cedaMoles.libs.migration.processor.loadResources import LoadResources
 from cedaMoles.libs.migration.db.classes import DataEntityMigration
-from cedaMoles.libs.migration.processor.commons import calculateHash
+from cedaMoles.libs.migration.processor.commons import calculate_hash
 
 class LoadResourceTest(CedaMolesTest):  
@@ -15 +15 @@
         migrationClass = DataEntityMigration()
         doc_id = 123
-        docHash = calculateHash('123_docHash')
+        docHash = calculate_hash('123_docHash')
         docCreation = '2009-12-10T03:16:25Z'
         lr.createMigrationDoc(migrationClass, doc_id, '123_docName', \
@@ -23 +23 @@
                                               docHash, docCreation))
         self.assertTrue(lr.updateMigrationDoc(migrationClass, doc_id, 
-                                                calculateHash('321_docHash'), \
+                                                calculate_hash('321_docHash'), \
                                             docCreation))
         self.assertTrue(lr.updateMigrationDoc(migrationClass, doc_id, \
-                                                calculateHash('321_docHash'), \
+                                                calculate_hash('321_docHash'), \
                                             '2012-12-10T03:16:25Z'))
                 

mauRepo/MolesManager/trunk/cedaMoles/tests/migration/moles3epbtests.py

@@ -5 +5 @@
 '''
 import logging, datetime
-from cedaMoles.libs.migration.processor.commons import createCI_Date, \
-    createDateTime, createDate, createTM_Position, createTM_Instant
+from cedaMoles.libs.migration.processor.commons import create_ci_date, \
+    create_datetime, create_date, create_tm_position, create_tm_instant
 from ea_model.iso_19115_2006_metadata_corrigendum.\
     citation_and_responsible_party_information.ci_datetypecode \
@@ -123 +123 @@
         session = self.epbRepo.moles3EPB.getNewMolesSession();
         py_date = datetime.date(2011, 4, 1)
-        dt = createDate(py_date)
-        ci_date = createCI_Date(CI_DateTypeCode.cl_creation, dt)
+        dt = create_date(py_date)
+        ci_date = create_ci_date(CI_DateTypeCode.cl_creation, dt)
         
         Moles3EPBTest.log.info('Stores an empty new CEDA_ObservationCollection')
@@ -213 +213 @@
     def _createDateTime(self):
         py_date = datetime.datetime(2011, 4, 1, 00, 00, 00)
-        return createDateTime(py_date)    
+        return create_datetime(py_date)    
     
     def _createCI_Date(self):
         py_date = datetime.date(2011, 4, 1)
-        dt = createDate(py_date)
-        return createCI_Date(CI_DateTypeCode.cl_creation, dt)
+        dt = create_date(py_date)
+        return create_ci_date(CI_DateTypeCode.cl_creation, dt)
     
     def _createTM_Position(self):
         newDateTime = self._createDateTime()                
-        return createTM_Position(dateTime8601 = newDateTime)
+        return create_tm_position(dateTime8601 = newDateTime)
 
     def _createTM_Instant(self):
         tm_position = self._createTM_Position()        
-        return createTM_Instant(tm_position)
+        return create_tm_instant(tm_position)

mauRepo/MolesManager/trunk/cedaMoles/tests/migration/test_utils.py

@@ -5 +5 @@
 '''
 from ea_model.ceda_metadatamodel.ceda_observationcollection.ceda_observationcollection import CEDA_ObservationCollection
-from cedaMoles.libs.migration.processor.commons import createCI_Citation,\
-    createMD_Identifier
+from cedaMoles.libs.migration.processor.commons import create_ci_citation,\
+    create_md_identifier
 from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation import CEDA_Observation
 from ea_model.ceda_metadatamodel.ceda_project.ceda_project import CEDA_Project
@@ -17 +17 @@
     '''
     observationCollection = CEDA_ObservationCollection()
-    auth = createCI_Citation('test_title')
-    i_identifier = createMD_Identifier(code = 'test_code', authority=auth)
+    auth = create_ci_citation('test_title')
+    i_identifier = create_md_identifier(code = 'test_code', authority=auth)
     observationCollection.identifier.append(i_identifier)      
     return observationCollection
@@ -31 +31 @@
     '''
     observation = CEDA_Observation()
-    i_identifier = createMD_Identifier(code = 'test_code', authority=createCI_Citation('test_title'))
+    i_identifier = create_md_identifier(code = 'test_code', authority=create_ci_citation('test_title'))
     observation.identifier.append(i_identifier)      
-    i_identifier = createMD_Identifier(code = 'mau_code', authority=createCI_Citation('mau_title'))
+    i_identifier = create_md_identifier(code = 'mau_code', authority=create_ci_citation('mau_title'))
     observation.identifier.append(i_identifier)  
     observation.dataLineage = "test_dataLineage"        

mauRepo/MolesManager/trunk/cedaMoles/tests/moles2gui/creationFactory.py

@@ -31 +31 @@
 @author: mnagni
 '''
-from cedaMoles.libs.migration.processor.commons import createCI_OnlineResource,\
-    createCI_Address, createCI_Telephone, createCI_Contact,\
-    createMO_Organization, createMO_Individual, createMO_ResponsiblePartyInfo,\
-    isoDateTimeStringToTimeDate, createDateTime, createTM_Position,\
-    createTM_Instant, fromDateStringToPhenomenonTime
+from cedaMoles.libs.migration.processor.commons import create_ci_onlineresource,\
+    create_ci_address, create_ci_telephone, create_ci_contact,\
+    create_mo_organization, create_mo_individual, create_mo_responsible_party_info,\
+    isoDateTimeStringToTimeDate, create_datetime, create_tm_position,\
+    create_tm_instant, from_date_string_to_pt
 from cedaMoles.MolesManager.codelist import getCLValue, MM_RoleValue
 from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation import CEDA_Observation
 
 def assembleMO_Individual(name = 'CedaTest', iid = 1):
-    ret = createMO_Individual(name = name)
+    ret = create_mo_individual(name = name)
     ret.id = iid
     return ret
@@ -46 +46 @@
 def assembleMO_Organization(name = 'UK Solar System Data Centre website', iid = 1):
     i_linkage = 'http://www.ukssdc.rl.ac.uk'
-    i_onlineResources = createCI_OnlineResource(linkage = i_linkage, name = name)
-    i_address = createCI_Address(deliveryPoint = ['UK Solar System Data Centre, STFC Rutherford Appleton Laboratory'], \
+    i_onlineResources = create_ci_onlineresource(linkage = i_linkage, name = name)
+    i_address = create_ci_address(deliveryPoint = ['UK Solar System Data Centre, STFC Rutherford Appleton Laboratory'], \
                                  electronicMailAddress=['support@rl.ac.uk'], postalCode='OX11 0QX', country='UK', city='Harwell Oxford')                                   
-    i_phone = createCI_Telephone(voice=['+44(0)1235 445173'])                                 
-    contact = createCI_Contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
-    ret = createMO_Organization(name = 'NERC - UK Solar System Data Centre', contactInfo = [contact])
+    i_phone = create_ci_telephone(voice=['+44(0)1235 445173'])                                 
+    contact = create_ci_contact(phone=i_phone, address=i_address, onlineResource=i_onlineResources)                       
+    ret = create_mo_organization(name = 'NERC - UK Solar System Data Centre', contactInfo = [contact])
     ret.id = iid
     return ret
@@ -60 +60 @@
     """
     party = [assembleMO_Individual(iid = 1), assembleMO_Organization(iid = 2)]
-    rp = createMO_ResponsiblePartyInfo(role, party)
+    rp = create_mo_responsible_party_info(role, party)
     rp.id =iid
     return rp
@@ -72 +72 @@
     """
     py_datetime = isoDateTimeStringToTimeDate(timestring)
-    date_time = createDateTime(py_datetime)    
-    tm_position = createTM_Position(dateTime8601 = date_time)
-    return createTM_Instant(tm_position)
+    date_time = create_datetime(py_datetime)    
+    tm_position = create_tm_position(dateTime8601 = date_time)
+    return create_tm_instant(tm_position)
 
 def assembleObservation(phenomenonTime = '2002-07-22/2011-08-06'):
@@ -80 +80 @@
     ceda_observation.relatedParty = assembleMO_ResponsiblePartyInfo()
     ceda_observation.resultTime = assembleTM_Instant()
-    ceda_observation.phenomenonTime = fromDateStringToPhenomenonTime(phenomenonTime)
+    ceda_observation.phenomenonTime = from_date_string_to_pt(phenomenonTime)
     return ceda_observation

mauRepo/MolesManager/trunk/cedaMoles/tests/moles2gui/om/period.py

@@ -35 +35 @@
 from cedaMoles.MolesManager.views.moles2gui import encodeCedaMoles2Json,\
     decodeJson2CedaMoles, getData
-from cedaMoles.libs.migration.processor.commons import fromDateStringToPhenomenonTime
+from cedaMoles.libs.migration.processor.commons import from_date_string_to_pt
 
 
@@ -54 +54 @@
         Validates a simple encode/decode
         """
-        period = fromDateStringToPhenomenonTime('2002-07-22/2011-08-06') 
+        period = from_date_string_to_pt('2002-07-22/2011-08-06') 
         json = encodeCedaMoles2Json(period)
         #----------------------- test ------------------------
@@ -70 +70 @@
         Decodes an updated json object
         """
-        period = fromDateStringToPhenomenonTime('2002-07-22/2011-08-06') 
+        period = from_date_string_to_pt('2002-07-22/2011-08-06') 
         json = encodeCedaMoles2Json(period)
         decJson = loads(json)