Changeset 8445 for mauRepo


Ignore:
Timestamp:
06/07/12 15:57:19 (7 years ago)
Author:
mnagni
Message:

Complete - # 22489: CEDA Observation Collection - phenomenonTime
 http://team.ceda.ac.uk/trac/ceda/ticket/22489
Complete - # 22488: CEDA Observation Collection - Geographical Extent
 http://team.ceda.ac.uk/trac/ceda/ticket/22488

Location:
mauRepo/MolesManager/trunk
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed

  • mauRepo/MolesManager/trunk/resources/requirements.txt

    r8430 r8445  
    1111# --extra-index-url http://ciprod1.cems.rl.ac.uk/pip 
    1212# to your pip install  
    13 ceda-moles-model==0.1.1 
     13ceda-moles-model==0.1.4 

  • mauRepo/MolesManager/trunk/src/MolesManager/moles3epb.py

    r8434 r8445  
    4949from ea_model.moles3_4.utilities.ceda_rolevalue import CEDA_RoleValue 
    5050from MolesManager.codelist import MM_RoleValue, getCLValue 
     51from libs.migration.processor.commons import fromPhenomenonTimeToString 
     52from datetime import datetime 
     53from ascore.utils import synchAttributes 
    5154 
    5255class Moles3EPBFactory(EPB): 
    … …  
    159162                    else: 
    160163                        setattr(coll, k, val) 
     164        synchAttributes(coll)                                              
    161165        self._controlledCommit() 
    162166        return coll                                       
    … …  
    174178        return unifyGeometriesAsBBox(bboxes, self)   
    175179         
     180    def getUnifyObservationCollectionPhenomenonTime(self, collection): 
     181        """ 
     182            Returns the time period of the collections.member'a  phenomenonTime(s) 
     183            @param collection: an CEDA_ObservationColleciton instance  
     184            @return: a tuple (startDate, endDate)  
     185        """ 
     186        ptStart = [] 
     187        ptEnd = []       
     188        for member in collection.member: 
     189            for pt in member.phenomenonTime: 
     190                ptString = fromPhenomenonTimeToString(pt) 
     191                if ptString[0] is not None:                     
     192                    ptStart.append(datetime.strptime(ptString[0], '%Y-%m-%d')) 
     193                if ptString[1] is not None:                     
     194                    ptEnd.append(datetime.strptime(ptString[1], '%Y-%m-%d')) 
     195        ptStart.sort()                     
     196        ptEnd.sort() 
     197        start = None 
     198        end = None 
     199        #takes the earlier date 
     200        if len(ptStart) > 0: 
     201            start = ptStart[0] 
     202        #takes the latest date 
     203        if len(ptEnd) > 0: 
     204            end = ptEnd[len(ptEnd) - 1] 
     205        return start, end   
     206         
     207         
     208         
     209        #return unifyGeometriesAsBBox(bboxes, self) 
     210 
    176211 
    177212    def retrieveGUIDFromInstance(self, instance): 
    … …  
    335370                       ge.eastBoundLongitude, ge.northBoundLatitude) 
    336371    return None 
     372 
     373def getUnifyObservationCollectionPhenomenonTime(collection): 
     374    """ 
     375        Returns the time period of the collections.member'a  phenomenonTime(s) 
     376        @param collection: an CEDA_ObservationColleciton instance  
     377        @return: a tuple (startDate, endDate) strings 
     378    """ 
     379    dateFormat = '%Y-%m-%d' 
     380    ptStart = [] 
     381    ptEnd = []       
     382    for member in collection.member: 
     383        if member.phenomenonTime is None: 
     384            continue 
     385             
     386        pt =  member.phenomenonTime 
     387        ptString = fromPhenomenonTimeToString(pt) 
     388        if ptString[0] is not None:                     
     389            ptStart.append(datetime.strptime(ptString[0], dateFormat)) 
     390        if ptString[1] is not None:                     
     391            ptEnd.append(datetime.strptime(ptString[1], dateFormat)) 
     392    ptStart.sort()                     
     393    ptEnd.sort() 
     394    start = None 
     395    end = None 
     396    #takes the earlier date 
     397    if len(ptStart) > 0: 
     398        start = ptStart[0].strftime(dateFormat)  
     399    #takes the latest date 
     400    if len(ptEnd) > 0: 
     401        end = ptEnd[len(ptEnd) - 1].strftime(dateFormat)  
     402    return start, end  

  • mauRepo/MolesManager/trunk/src/MolesManager/static/js/cedaSearch.js

    r8289 r8445  
    1 ''' 
    2 Created on 1 Nov 2011 
     1define(['dojo'], function(dojo){ 
     2        console.log("loads cedaSearch.js") 
     3   // function <nameOfFunction>(parameter, parameter2..etc coming in){ 
     4   //    write operations to prepare value to return 
     5   //      
     6   //    return(<value>); 
     7   //      } 
    38 
    4 @author: mnagni 
    5 ''' 
    6 from django.shortcuts import render_to_response, redirect 
    7 from django.core.context_processors import csrf 
    8 from MolesManager.views import cedaObservationView 
    9 from MolesManager.ceda_guid import CedaGUID 
    10 from MolesManager.moles3epb import Moles3EPB 
     9        require(['dojo/ready', 'dojo/parser', 'dijit/registry', 'dojo/_base/json', 'dojo/store/Memory', 
     10                 'dijit/Tree', 'dijit/form/Button'], function(ready, parser, registry, Tree){ 
     11                 ready(function () { 
     12                          
     13                         //---------------------------------------------- 
     14                         //----- Initializes the necessary widgets ------ 
     15                         //---------------------------------------------- 
     16                         //var obs_id = new dijit.form.TextBox({ 
     17                        //       value: '' /* no or empty value! */ 
     18                         //}, 'obs_id'); 
     19                         //obs_id.startup(); 
     20                          
     21                         var button = new dijit.form.Button({ 
     22                                 type: "submit", 
     23                         label: "Search", 
     24                        // onClick: function(){ console.log("First button was clicked!"); } 
     25                     }, "search_obs"); 
     26                     button.startup(); 
     27                          
     28                         var records_dataLineage = new dijit.form.Textarea({ 
     29                                 value: "" 
     30                         }, "records_dataLineage"); 
     31                         records_dataLineage.startup();  
    1132 
    12  
    13 """ 
    14 def __getResponseByGuid(request, guid): 
    15     ceda_guid = Moles3EPB.search(CedaGUID, guid, request.moles_session) 
    16     if ceda_guid and ceda_guid.ceda_observation: 
    17         return redirect(cedaObservationView.coView, ceda_guid.ceda_observation) 
    18 """ 
    19  
    20 def __doSearch(request, keywords): 
    21     ''' 
    22     @param request: an HttpRequest 
    23     @param keywords: an list of strings  
    24     @return: the first Observation or None  
    25     '''     
    26     obsevations = Moles3EPB.extractObservationByTitleKeywords(keywords, request.moles_session)       
    27     titles = []  
    28     for o in obsevations: 
    29       titles.append(o.identifier[0].authority.title) 
    30     #return obsevations.first() 
    31     return titles 
    32  
    33  
    34 def coSearch(request): 
    35     c = {}     
    36     if 'searchTerm' in request.POST: 
    37         c['searchResults'] = __doSearch(request, request.POST['searchTerm']) 
    38              
    39     c.update(csrf(request)) 
    40     if c == {} : 
    41         print "AAA" 
    42         return render_to_response('cedaObservation.html', c)   
    43     else : 
    44         print "BBB" 
    45         found = False 
    46         try: 
    47                 a = c['searchResults'] 
    48                 found = True 
    49         except Exception, ex: 
    50                 pass 
    51         #for a in c: 
    52         #       b=c[a] 
    53         #       print "b=", b, "a=", a 
    54         #       if a != "csrf_token": 
    55         #               print b.result 
    56         #       #if b.hasattr("__key__"): 
    57         #       #       print b.__key__ 
    58         if not found: 
    59                 return render_to_response('cedaSearch.html', c) 
    60         return render_to_response('cedaSearchResults.html', c) 
     33                         //---------------------------------------------- 
     34                         //---------- Loads the widgets values ---------- 
     35                         //---------------------------------------------- 
     36                                  
     37                         var json = dojo.byTitle('coSearch_id').value; 
     38                                 var coObs = dojo.fromJson(json); 
     39                                 dojo.attr("title_id", 'value', ''); 
     40                 });                                       
     41        }); 
     42}); 

  • mauRepo/MolesManager/trunk/src/MolesManager/urls.py

    r8433 r8445  
    2121urlpatterns += patterns('MolesManager.views.cedaObservationView', 
    2222 
    23     (r'cov/(\w+)$', 'coView'), 
     23    (r'cov/(\d+)$', 'objView'), 
    2424) 
     25 
     26urlpatterns += patterns('MolesManager.views.cedaObservationCollectionView', 
     27 
     28    (r'cov2/(\d+)$', 'objView'), 
     29) 
     30 
     31urlpatterns += patterns('MolesManager.views.cedaSearch', 
     32    (r'guid/(\w+)$', 'getResponseByGuid'), 
     33) 
     34 
     35 
    2536 
    2637urlpatterns += patterns('MolesManager.views.cedaBrowse', 

  • mauRepo/MolesManager/trunk/src/MolesManager/views/cedaObservationView.py

    r8435 r8445  
    3434from django.core.context_processors import csrf 
    3535from MolesManager.djencoder import encodeToJSON 
    36 #from django.utils.safestring import mark_safe 
    3736from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation import CEDA_Observation 
    3837 
    3938 
    4039 
    41 def coView(request, obs_id_str): 
     40def objView(request, req_id_str): 
    4241    record = None 
    4342    try: 
    44         obs_id = int(obs_id_str) 
    45         record =  _getCedaObservation(request, obs_id)         
     43        req_id = int(req_id_str) 
     44        record =  _getCedaObservation(request, req_id)         
    4645    except ValueError: 
    4746        pass 
    … …  
    6867                      'inSupportOf.abstract', 'dataLineage'] 
    6968    return request.moles3EPB.searchSelectiveLoad(CEDA_Observation, obs_id, eagerloadthese) 
    70     #return Moles3EPB.searchEager(CEDA_Observation, obs_id) 

  • mauRepo/MolesManager/trunk/src/MolesManager/views/cedaSearch.py

    r8434 r8445  
    55''' 
    66from django.core.context_processors import csrf 
    7 from django.shortcuts import render_to_response 
     7from django.shortcuts import render_to_response, redirect 
     8from MolesManager.ceda_guid import CedaGUID 
     9import cedaObservationView 
     10import cedaObservationCollectionView 
    811 
    9 """ 
    10 def __getResponseByGuid(request, guid): 
    11     ceda_guid = Moles3EPB.search(CedaGUID, guid, request.moles_session) 
     12def getResponseByGuid(request, guid): 
     13    ceda_guid = request.moles3EPB.search(CedaGUID, guid) 
    1214    if ceda_guid and ceda_guid.ceda_observation: 
    13         return redirect(cedaObservationView.coView, ceda_guid.ceda_observation) 
    14 """ 
     15        return cedaObservationView.objView(request, ceda_guid.ceda_observation) 
     16    if ceda_guid and ceda_guid.ceda_observationcollection: 
     17        return cedaObservationCollectionView.objView(request, ceda_guid.ceda_observationcollection)     
    1518 
    1619def __doSearch(request, keywords): 

  • mauRepo/MolesManager/trunk/src/MolesManager/views/cedacat.py

    r8339 r8445  
    1313    ceda_guid = request.moles3EPB.search(CedaGUID, guid) 
    1414    if ceda_guid and ceda_guid.ceda_observation: 
    15         return redirect(cedaObservationView.coView, ceda_guid.ceda_observation) 
     15        return redirect(cedaObservationView.objView, ceda_guid.ceda_observation) 
    1616 
    1717    if ceda_guid and ceda_guid.ceda_observationcollection: 

  • mauRepo/MolesManager/trunk/src/libs/epb.py

    r8435 r8445  
    191191    @classmethod 
    192192    def _drillALLData(cls, obj): 
     193        if obj is None: 
     194            return 
    193195        if isinstance(obj, list): 
    194196            for element in obj: 

  • mauRepo/MolesManager/trunk/src/libs/migration/processor/commons.py

    r8433 r8445  
    7070from ea_model.ceda_metadatamodel.ceda_computation.ceda_processing import CEDA_Processing 
    7171from ea_model.ceda_metadatamodel.ceda_result.ceda_result import CEDA_Result 
     72import datetime 
    7273 
    7374base = '/exist/rest/atoms' 
    … …  
    935936        ceda_project.projectResource = project_resource    
    936937    return ceda_project 
     938 
     939def fromDateStringToPhenomenonTime(doc_phenomenon_time): 
     940    """ 
     941        Transforms a date string like '2002-07-22' (startDate) in a TM_Instant instance or    
     942        '2002-07-22/2011-08-06' (start/endDate) in a TM_Period instance 
     943        @param doc_phenomenon_time: a date string in the expected format 
     944    """ 
     945    if doc_phenomenon_time: 
     946        pt = None 
     947        if '/' in doc_phenomenon_time: 
     948            period = doc_phenomenon_time.split('/') 
     949            begin_date = createDate(isoDateStringToTimeDate(period[0])) 
     950            begin_position = createTM_Position(date8601 = begin_date) 
     951            begin_tm_instant = createTM_Instant(begin_position) 
     952             
     953            end_date = createDate(isoDateStringToTimeDate(period[1])) 
     954            end_position = createTM_Position(date8601 = end_date) 
     955            end_tm_instant = createTM_Instant(end_position) 
     956             
     957            pt = createTM_Period(begin_tm_instant, end_tm_instant) 
     958        else: 
     959            tm_position = createTM_Position(date8601 = createDate(isoDateStringToTimeDate(doc_phenomenon_time))) 
     960            pt = createTM_Instant(tm_position) 
     961    return pt 
     962 
     963def fromPhenomenonTimeToString(phenomenonTime): 
     964    """ 
     965        Transforms a TM_Instant instance in a date string like '2002-07-22' (startDate) or    
     966        a TM_Period instance in a string like '2002-07-22/2011-08-06' (start/endDate)  
     967        @param phenomenonTime: a aTM_Instace or a TM_Period instance 
     968        @return a pair startDate, endDate. If endDate does not exists return startDate, None 
     969    """    
     970    if phenomenonTime is None: 
     971        return None 
     972    startDate =None 
     973    endDate = None 
     974    if isinstance(phenomenonTime, TM_Instant): 
     975        startDate = _tm_InstantToString(phenomenonTime) 
     976    elif isinstance(phenomenonTime, TM_Period): 
     977        startDate = _tm_InstantToString(phenomenonTime.begin)         
     978        endDate = _tm_InstantToString(phenomenonTime.end) 
     979    return startDate, endDate 
     980 
     981def comparePhenomenonTimes(p1, p2): 
     982    s1 = fromPhenomenonTimeToString(p1) 
     983    s2 = fromPhenomenonTimeToString(p2) 
     984    return s1[0] == s2[0] and s1[1] == s2[1]  
     985 
     986def _tm_InstantToString(tm_instant): 
     987    idate = tm_instant.position.date8601 
     988    return str(datetime.date(int(idate.year), int(idate.month), int(idate.day))) 
     989 
     990def fromGeographicBoundingBoxToString(geographicBoundingBox): 
     991    if geographicBoundingBox is None: 
     992        return None 
     993    return ('%f %f,%f %f') % (geographicBoundingBox.eastBoundLongitude, geographicBoundingBox.northBoundLatitude, \ 
     994                              geographicBoundingBox.westBoundLongitude, geographicBoundingBox.southBoundLatitude) 
    937995     
     996def compareGeographicBoundingBoxes(gb1, gb2): 
     997    return fromGeographicBoundingBoxToString(gb1) == fromGeographicBoundingBoxToString(gb2) 

  • mauRepo/MolesManager/trunk/src/libs/migration/processor/dataEntity.py

    r8433 r8445  
    4040    calculateHash, findDOIInMigrationDocument,\ 
    4141    hasMOBeenProcessed, getAtomDocumentHashByMO, extractTitle, extractSummary,\ 
    42     createEX_GeographicBoundingBox 
     42    createEX_GeographicBoundingBox, fromDateStringToPhenomenonTime,\ 
     43    comparePhenomenonTimes, compareGeographicBoundingBoxes 
    4344from libs.migration.processor.deployment import DeploymentProcessor 
    4445from logging import StreamHandler 
    … …  
    4950    getCLValue 
    5051from ea_model.ceda_metadatamodel.ceda_observationcollection.ceda_observationcollection import CEDA_ObservationCollection  
     52from MolesManager.moles3epb import getUnifyObservationCollectionPhenomenonTime 
    5153CEDA_TITLE = 'ceda_title' 
    5254 
    … …  
    8082            geographicExtent = createEX_GeographicBoundingBox(float(east), float(north), \ 
    8183                                                              float(west), float(south)) 
    82             if self._dataEntityHasBeenProcessed: 
    83                 DataEntityProcessor.log.warn('The _assignGeographicExtent update is skipped because not implemented') 
    84                 return 
    85              
    86             self.epbRepo.moles3EPB.updateCedaObject(ceda_observationCollection, {'geographicExtent': geographicExtent})                         
     84             
     85            if len(ceda_observationCollection.geographicExtent) == 0 or \ 
     86                (len(ceda_observationCollection.geographicExtent) > 0 and \ 
     87                    not compareGeographicBoundingBoxes(geographicExtent, \ 
     88                                                  ceda_observationCollection.geographicExtent[0])): 
     89                self.epbRepo.moles3EPB.updateCedaObject(ceda_observationCollection, \ 
     90                                                        {'geographicExtent': geographicExtent})                         
    8791        else: 
    8892            self._report.append(NoGeographicalExtensionException(self._dataEntityMigration))           
    8993         
     94    def _assignPhenomenonTime(self, ceda_observationCollection): 
     95        start, end = getUnifyObservationCollectionPhenomenonTime(ceda_observationCollection) 
     96        dateString = start 
     97        if end is not None: 
     98            dateString = '%s/%s' % (start, end) 
     99        pt = fromDateStringToPhenomenonTime(dateString) 
     100         
     101        if ceda_observationCollection.phenomenonTime is not None \ 
     102            and (len(ceda_observationCollection.phenomenonTime) == 0 \ 
     103                 or (len(ceda_observationCollection.phenomenonTime) == 1 and \ 
     104                     not comparePhenomenonTimes(ceda_observationCollection.phenomenonTime[0], pt))): 
     105            self.epbRepo.moles3EPB.updateCedaObject(ceda_observationCollection, {'phenomenonTime': pt})         
    90106 
    91107    def _assignDescription(self, ceda_observationCollection): 
    … …  
    243259            except Exception as ex: 
    244260                self._report.append(ex)                 
     261                         
    245262        self._assignGeographicExtent(obsColl) 
     263        self._assignPhenomenonTime(obsColl)         
    246264           
    247265        return self._report 

  • mauRepo/MolesManager/trunk/src/libs/migration/processor/deployment.py

    r8435 r8445  
    5050    createCI_ResponsibleParty, extractUpdateFrequency,\ 
    5151    findLinksInMigrationDocument, findSubTypeInDPT, extractMolesPublishedDate,\ 
    52     createMD_Keywords, hasMOBeenProcessed, createMO_Individual 
     52    createMD_Keywords, hasMOBeenProcessed, createMO_Individual,\ 
     53    fromDateStringToPhenomenonTime, fromPhenomenonTimeToString,\ 
     54    comparePhenomenonTimes 
    5355from libs.epb import EPB 
    5456from libs.migration.processor.deployment_data import DeploymentDataProcessor 
    … …  
    439441        #Still have to update observation.geographicExtent 
    440442 
    441     def _assignPhenomenonTime(self, observation):   
     443    def _assignPhenomenonTime(self, observation): 
    442444        if self._deploymentHasSameHash and getattr(observation, 'phenomenonTime') != None: 
    443445            return   
    444446               
    445         doc_phenomenon_time = extractMolesTemporalRange(self._deploymentMigration)         
    446         if doc_phenomenon_time: 
    447             pt = None 
    448             if '/' in doc_phenomenon_time: 
    449                 period = doc_phenomenon_time.split('/') 
    450                 begin_date = createDate(isoDateStringToTimeDate(period[0])) 
    451                 begin_position = createTM_Position(date8601 = begin_date) 
    452                 begin_tm_instant = createTM_Instant(begin_position) 
    453                  
    454                 end_date = createDate(isoDateStringToTimeDate(period[1])) 
    455                 end_position = createTM_Position(date8601 = end_date) 
    456                 end_tm_instant = createTM_Instant(end_position) 
    457                  
    458                 pt = createTM_Period(begin_tm_instant, end_tm_instant) 
    459             else: 
    460                 tm_position = createTM_Position(date8601 = createDate(isoDateStringToTimeDate(doc_phenomenon_time))) 
    461                 pt = createTM_Instant(tm_position) 
    462              
    463             if not self._deploymentHasBeenProcessed: 
    464                 observation.phenomenonTime = pt 
    465         #Still have to update observation.phenomenonTime                 
     447        doc_phenomenon_time = extractMolesTemporalRange(self._deploymentMigration)  
     448        pt = fromDateStringToPhenomenonTime(doc_phenomenon_time)     
     449         
     450        if not self._deploymentHasBeenProcessed or not comparePhenomenonTimes(pt,observation.phenomenonTime): 
     451            self.epbRepo.moles3EPB.updateCedaObject(observation, {'phenomenonTime': pt}) 
     452        #Now update phenomenonTime but has to remove the previous phenomenonTime                 
    466453                 
    467454    def _assignPermission(self, observation): 

  • mauRepo/MolesManager/trunk/src/libs/migration/tests/commontest.py

    r8186 r8445  
    55''' 
    66from unittest import TestCase 
    7 from libs.migration.processor.commons import isoDateTimeStringToTimeDate 
     7from libs.migration.processor.commons import isoDateTimeStringToTimeDate,\ 
     8    fromDateStringToPhenomenonTime, fromPhenomenonTimeToString,\ 
     9    comparePhenomenonTimes 
    810 
    911 
    … …  
    2123        self.assertRaises(ValueError, isoDateTimeStringToTimeDate, time1) 
    2224 
     25    def testFromDateStringToPhenomenonTime(self): 
     26        temporalRange = '2002-07-22/2011-08-06' 
     27        pt = fromDateStringToPhenomenonTime(temporalRange) 
     28        print pt 
    2329         
    24  
     30    def testFromPhenomenonTimeToString(self): 
     31        temporalRange = '2002-07-22/2011-08-06' 
     32        pt = fromDateStringToPhenomenonTime(temporalRange) 
     33        ptString = fromPhenomenonTimeToString(pt) 
     34        startDate, endDate = temporalRange.split('/')         
     35        self.assertTrue(startDate == ptString[0], "Error")         
     36        self.assertTrue(endDate == ptString[1], "Error")         
    2537         
     38        temporalRange = '2002-07-22' 
     39        pt = fromDateStringToPhenomenonTime(temporalRange) 
     40        ptString = fromPhenomenonTimeToString(pt) 
     41        startDate, endDate = temporalRange, None         
     42        self.assertTrue(startDate == ptString[0], "Error")         
     43        self.assertTrue(endDate == ptString[1], "Error") 
    2644         
     45    def testComparePhenomenonTimes(self): 
     46        p1 = fromDateStringToPhenomenonTime('2002-07-22/2011-08-06') 
     47        p2 = fromDateStringToPhenomenonTime('2002-07-22/2011-08-06') 
     48        self.assertTrue(comparePhenomenonTimes(p1,p2), "Error") 
    2749         
     50        p2 = fromDateStringToPhenomenonTime('2002-07-22/2011-08-05') 
     51        self.assertFalse(comparePhenomenonTimes(p1,p2), "Error") 
     52         
     53        p2 = fromDateStringToPhenomenonTime('2002-07-22') 
     54        self.assertFalse(comparePhenomenonTimes(p1,p2), "Error") 
     55         
Note: See TracChangeset for help on using the changeset viewer.