Changeset 8548 for mauRepo


Ignore:
Timestamp:
31/08/12 15:23:41 (7 years ago)
Author:
mnagni
Message:

Complete - # 22528: Migration of FAtCat Open Search link for HPFeld
 http://team.ceda.ac.uk/trac/ceda/ticket/22528
Incomplete - # 22551: List resources / display single file
 http://team.ceda.ac.uk/trac/ceda/ticket/22551
Parse better the fatcatOS. drill down to the file level. Fixes the non_root_url problem

Location:
mauRepo/HPFos/trunk/hpfos
Files:
3 added
7 edited

Legend:

Unmodified
Added
Removed
  • mauRepo/HPFos/trunk/hpfos/HPFos/moles3epb.py

    r8515 r8548  
    4444import logging 
    4545from logging import StreamHandler 
    46 from hpfos.libs.postgisutil import create_st_setSRID, unifyGeometries,\ 
     46from hpfos.libs.postgisutil import create_st_setSRID,\ 
    4747    intersectGeometries 
     48from hpfos.HPFos.db.tm_instant import customize_tm_instant 
    4849 
    4950class Moles3EPBFactory(EPB): 
    5051    
    51     def __init__(self, dbManager): 
    52         self._dbManager = dbManager 
     52    def __init__(self, db_manager): 
     53        self._db_manager = db_manager 
    5354        self._initCEDA_Customization()    
    5455         
     
    5657    def _initCEDA_Customization(self): 
    5758        self._associateCEDA_GUID() 
    58         #self._initSearchIndexes()         
     59        customize_tm_instant(self._db_manager.engine, self._db_manager.metadata)         
    5960         
    6061    def _associateCEDA_GUID(self): 
    61         guid_table = Table('ceda_guid', self._dbManager.metadata, \ 
     62        guid_table = Table('ceda_guid', self._db_manager.metadata, \ 
    6263                           Column('id', String, primary_key=True), \ 
    6364                           Column('ceda_observationcollection', Integer, ForeignKey('ceda_observationcollection.id')),  
    6465                           Column('ceda_observation', Integer, ForeignKey('ceda_observation.id'))) 
    6566        mapper(CedaGUID, guid_table) 
    66         self._dbManager.metadata.create_all() 
     67        self._db_manager.metadata.create_all() 
    6768 
    6869    def _getSession(self): 
    69         if self._dbManager is not None: 
    70             return self._dbManager.createDbSession()                 
     70        if self._db_manager is not None: 
     71            return self._db_manager.createDbSession()                 
    7172        return None 
    7273         
     
    8586        return self._session.close()                           
    8687         
    87     def getObservationCollections(self, bbox = None, keywords = '*'): 
     88    def getObservationCollections(self, bbox = None, keywords = '*',  
     89                                  start = None, end = None): 
    8890        """ 
    8991            Returns the stored CEDA_ObservationCollection eventually filtering them against a postgis goemetry 
     
    9294        """ 
    9395         
    94         collections = self._session.query(CEDA_ObservationCollection) 
    95         res = []  
     96        collections = self._session.query(CEDA_ObservationCollection)         
     97        if keywords != '*' and keywords is not None: 
     98            collections = collections.\ 
     99                join(MO_ObservationCollection).join(MO_Observation.identifier). \ 
     100                filter('md_identifier.code_search_vector @@ to_tsquery(:terms)').\ 
     101                filter("mo_observationcollection.description @@ to_tsquery(:terms)").\ 
     102                params(terms=keywords)  
     103        res = None  
    96104        #collections = self._extract_observation_collection_by_title_keywords(keywords) 
    97105        if collections is None: 
    98             return res    
    99         if bbox == None: 
    100             return collections.all() 
    101          
    102  
     106            return []    
     107         
     108        res = collections.all() 
     109        if bbox is None and start is None and end is None: 
     110            return res 
     111 
     112        res = self._filter_bbox(collections, bbox); 
     113        res = self._filter_time(res, start, end) 
     114        return res 
     115 
     116    def _filter_bbox(self, collections, bbox): 
     117        if bbox is None: 
     118            collections  
     119        res = [] 
    103120        for collection in collections: 
    104121            if len(collection.geographicExtent) > 0: 
     
    110127        return res 
    111128 
     129    def _filter_time(self, collections, start, end): 
     130        if start is None and end is None: 
     131            return collections 
     132        res = []         
     133        for collection in collections: 
     134            for phenomenon in collection.phenomenonTime: 
     135                #is a TM_Instant? 
     136                if hasattr(phenomenon, 'ceda_timestamp'): 
     137                    if start is not None and start < phenomenon.ceda_timestamp: 
     138                        res.append(collection) 
     139                        break 
     140                #is a TM_Period?                     
     141                if hasattr(phenomenon, 'start') and hasattr(phenomenon, 'end'): 
     142                    if start is not None \ 
     143                            and end is None \ 
     144                            and start < phenomenon.start.ceda_timestamp: 
     145                        res.append(collection) 
     146                        break 
     147                    if start is not None \ 
     148                            and end is not None \ 
     149                            and start < phenomenon.start.ceda_timestamp \ 
     150                            and end > phenomenon.end.ceda_timestamp: 
     151                        res.append(collection) 
     152                        break 
     153 
    112154    def retrieveGUIDFromInstance(self, instance): 
    113155        """ 
     
    135177                return self.search(CEDA_ObservationCollection, ceda_guid.ceda_observationcollection) 
    136178        return None 
    137  
    138     def _extract_observation_collection_by_title_keywords(self, keywords): 
    139         """ 
    140             Loooks for CEDA_ObservationCollection containing a specific title (observationCollection.identifier.code) 
    141             @param keywords: a space separated terms string   
    142         """                 
    143         # search_vector is a ts_vector column. To search for terms, you use the  
    144         # @@ operator. plainto_tsquery turns a string into a query that can be  
    145         # used with @@. So this adds a where clause like "WHERE search_vector  
    146         # @@ plaint_tsquery(<search string>)" 
    147         q = self._session.query(CEDA_ObservationCollection). \ 
    148             join(MO_ObservationCollection).join(MO_Observation.identifier). \ 
    149             filter('md_identifier.code_search_vector @@ to_tsquery(:terms)') 
    150         # This binds the :terms placeholder to the searchterms string. User input  
    151         # should always be put into queries this way to prevent SQL injection. 
    152         q = q.params(terms=keywords) 
    153179 
    154180    def search(self, clazz, inst_key): 
  • mauRepo/HPFos/trunk/hpfos/HPFos/osImpl/commons.py

    r8529 r8548  
    3434from xml.etree.ElementTree import XML 
    3535import urllib2 
     36from ea_model.iso_19108_2006_temporal_schema.temporal_objects.tm_instant import TM_Instant 
     37from ea_model.iso_19108_2006_temporal_schema.temporal_objects.tm_period import TM_Period 
     38import datetime 
     39 
     40DATE_FORMAT = '%Y-%m-%d' 
     41DATETIME_FORMAT = DATE_FORMAT + 'T%H:%M:%SZ' 
     42 
     43def tm_InstantToDatetime(tm_instant): 
     44    idate = tm_instant.position.date8601 
     45    return datetime.date(int(idate.year), int(idate.month), int(idate.day)) 
     46 
     47def isoDateStringToDatetime(datestring): 
     48    try: 
     49        return _isoDateStringToTimeDate(datestring) 
     50    except: 
     51        try: 
     52            return _isoDateTimeStringToTimeDate(datestring) 
     53        except: 
     54            pass 
     55 
     56def _isoDateStringToTimeDate(datestring): 
     57    ''' 
     58        Return a datatime.datatime instance. 
     59        @param datestring: a date string formatted as '%Y-%m-%d' 
     60    ''' 
     61    return datetime.datetime.strptime(datestring, DATE_FORMAT) 
     62 
     63def _isoDateTimeStringToTimeDate(timestring): 
     64    ''' 
     65        Return a datatime.datatime instance. 
     66        @param timestring: a time string formatted as '%Y-%m-%dT%H:%M:%SZ' 
     67    ''' 
     68    try: 
     69        return datetime.datetime.strptime(timestring, DATETIME_FORMAT) 
     70    except: 
     71        pass 
     72 
     73def from_pt_to_string(phenomenonTime): 
     74    """ 
     75        Transforms a TM_Instant instance in a date string like '2002-07-22' (startDate) or    
     76        a TM_Period instance in a string like '2002-07-22/2011-08-06' (start/endDate)  
     77        @param phenomenonTime: a aTM_Instace or a TM_Period instance 
     78        @return a pair startDate, endDate. If endDate does not exists return startDate,  
     79        None 
     80    """    
     81    if phenomenonTime is None: 
     82        return None 
     83    startDate =None 
     84    endDate = None 
     85    if isinstance(phenomenonTime, TM_Instant): 
     86        startDate = _tm_InstantToString(phenomenonTime) 
     87    elif isinstance(phenomenonTime, TM_Period): 
     88        startDate = _tm_InstantToString(phenomenonTime.begin)         
     89        endDate = _tm_InstantToString(phenomenonTime.end) 
     90    return startDate, endDate 
     91 
     92def _tm_InstantToString(tm_instant): 
     93    idate = tm_instant.position.date8601 
     94    return datetime.datetime(int(idate.year), int(idate.month), int(idate.day), 0, 0, 0).isoformat() 
    3695 
    3796def return_not_none_text(element): 
  • mauRepo/HPFos/trunk/hpfos/HPFos/osImpl/myimpl.py

    r8534 r8548  
    3131@author: Maurizio Nagni 
    3232''' 
    33 from datetime import datetime 
     33from datetime import datetime, date 
    3434from hpfos.libs.postgisutil import create_st_setSRID 
    3535from ceda_markup.opensearch.osquery import OSQuery 
     
    3838from ceda_markup.atom.info import createTitle, HTML_TYPE, createContent 
    3939from ceda_markup.dc.dc import createDate 
    40 from ceda_markup.gml.gml import createPosList, createLinearRing, createExterior,\ 
    41     createPolygon 
     40from ceda_markup.gml.gml import createBeginPosition, createEndPosition, \ 
     41    createTimePeriod, createValidTime, createEnvelope, createLowerCorner, \ 
     42    createUpperCorner, createPosList, createLinearRing, createExterior, createPolygon,\ 
     43    GML_NAMESPACE 
    4244from ceda_markup.georss.georss import createWhere 
    43 from ceda_markup.atom.link import REL_SEARCH, REL_ALTERNATE 
     45from ceda_markup.atom.link import REL_SEARCH, REL_ALTERNATE, createLink 
    4446from ceda_markup.opensearch import filter_results, COUNT_DEFAULT,\ 
    4547    START_INDEX_DEFAULT, START_PAGE_DEFAULT, create_autodiscovery_link 
     
    4749from ceda_markup.opensearch.template.atom import OSAtomResponse 
    4850from ceda_markup.opensearch.template.html import OSHTMLResponse 
    49 from ea_model.ceda_metadatamodel.ceda_observationcollection.ceda_observationcollection import CEDA_ObservationCollection 
    50 from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation import CEDA_Observation 
     51from ea_model.iso_19108_2006_temporal_schema.temporal_objects.tm_instant import TM_Instant 
     52from ea_model.ceda_metadatamodel.ceda_observationcollection.ceda_observationcollection \ 
     53    import CEDA_ObservationCollection 
     54from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation \ 
     55    import CEDA_Observation 
    5156from ea_model.ceda_metadatamodel.ceda_result.ceda_result import CEDA_Result 
    5257from ceda_markup.opensearch.os_param import OSParam 
    5358from hpfos import __version__, __revision__ 
    5459from ceda_markup.atom.atom import ATOM_NAMESPACE 
    55 from hpfos.HPFos.osImpl.commons import get_document, get_xml_document 
    56 from ceda_markup.opensearch.os_request import OpenSearchDescription, OS_NAMESPACE 
     60from hpfos.HPFos.osImpl.commons import get_document, get_xml_document, \ 
     61    from_pt_to_string, isoDateStringToDatetime, tm_InstantToDatetime 
     62from ceda_markup.opensearch.os_request import OS_NAMESPACE 
    5763from xml.etree.ElementTree import _ElementInterface 
     64from ea_model.iso_19115_2006_metadata_corrigendum.\ 
     65    extent_information.ex_geographicboundingbox import EX_GeographicBoundingBox 
    5866 
    5967GUID = 'guid' 
     68FILE_ID = 'guid' 
    6069COLLECTION = 'collection' 
    6170OBSERVATION = 'observation' 
     
    6473DUMMY_GUID = 'dummy_guid' 
    6574 
    66 FATCAT_HOST = 'citest1.jc.rl.ac.uk' 
     75FATCAT_HOST = 'cidev1.jc.rl.ac.uk' 
    6776FATCAT_ROOT_PATH = 'fatcatOS' 
    6877PROXY_URL = 'http://wwwcache.rl.ac.uk:8080' 
     
    94103        Constructor 
    95104        ''' 
    96  
    97     def _get_tot_results(self, results): 
    98         if results is None: 
    99             return 0 
    100          
    101         if isinstance(results, list): 
    102             return len(results) 
    103          
    104         return 1 
    105105     
    106106    def _digest_fatcat_atom(self, context, results): 
    107107        count, start_index, start_page = self._importCountAndPage(context) 
    108         subresults = results.findall('{%s}entry' % (ATOM_NAMESPACE)) 
    109         tot_results = int(results.find('{%s}totalResults' % (OS_NAMESPACE)).text.replace('\n','').strip()) 
    110         return Result(count, start_index, start_page, tot_results, subresult = subresults, title=HPFOS_TITLE)         
     108        entries = results.findall('{%s}entry' % (ATOM_NAMESPACE)) 
     109        subresults = [] 
     110        for entry in entries: 
     111            iid = entry.find('{%s}id' % (ATOM_NAMESPACE)).text.strip() 
     112            ititle = entry.find('{%s}title' % (ATOM_NAMESPACE)).text.strip() 
     113            kwargs = {} 
     114                          
     115            element = entry.find('.//{%s}beginPosition' % (GML_NAMESPACE)) 
     116            if element is not None: 
     117                kwargs['beginPosition'] = element.text.strip() 
     118                element = None 
     119             
     120            element = entry.find('.//{%s}endPosition' % (GML_NAMESPACE)) 
     121            if element is not None: 
     122                kwargs['endPosition'] = element.text.strip() 
     123                element = None             
     124             
     125            geometry = entry.find('.//{%s}posList' % (GML_NAMESPACE)) 
     126            if geometry is not None: 
     127                kwargs['geometry'] = 'POLYGON((%s))' % geometry.text.strip() 
     128            else: 
     129                geometry = entry.find('.//{%s}Envelope' % (GML_NAMESPACE)) 
     130                if geometry is not None: 
     131                    lc = geometry.find('./{%s}lowerCorner' % (GML_NAMESPACE)).text.strip() 
     132                    uc = geometry.find('./{%s}upperCorner' % (GML_NAMESPACE)).text.strip() 
     133                    kwargs['geometry'] = _create_box2d(lc, uc) 
     134 
     135 
     136            kwargs['enclosure'] = entry.findall("./{%s}link" % (ATOM_NAMESPACE)) 
     137            #This can be activated on python >= 2.7 
     138            #kwargs['enclosure'] = entry.findall("./{%s}link[@rel='enclosure']" % (ATOM_NAMESPACE))                          
     139            kwargs['description'] = 'no description' 
     140            subresults.append(Subresult(iid, ititle,  
     141                                        datetime.now().isoformat(), **kwargs)) 
     142         
     143        tot_results = int(results.find('{%s}totalResults'  
     144                                       % (OS_NAMESPACE)).text.replace('\n','').strip()) 
     145        return Result(count, start_index, start_page, tot_results,  
     146                      subresult = subresults, title=HPFOS_TITLE)         
    111147         
    112148    def _check_text_filter(self, text, title, description): 
     
    117153                    return True 
    118154        return False 
    119          
    120  
    121     def digest_search_results(self, results, context):  
    122         count, start_index, start_page = self._importCountAndPage(context) 
    123          
    124         filtered = None 
    125         tot_results = 0 
    126          
    127         if type(results) == CEDA_ObservationCollection: 
    128             filtered = filter_results(results.member, count, start_index, start_page) 
    129             tot_results = self._get_tot_results(results.member) 
    130         elif type(results) == CEDA_Observation: 
    131             #to be done 
    132             filtered = filter_results(results.result, count, start_index, start_page) 
    133             tot_results = self._get_tot_results(results.result) 
    134         elif type(results) == CEDA_Result: 
    135             filtered = filter_results(results.result, count, start_index, start_page) 
    136             tot_results = 1   
    137         elif isinstance(results, _ElementInterface): 
    138             return self._digest_fatcat_atom(context, results)                                  
    139         else: 
    140             filtered = filter_results(results, count, start_index, start_page) 
    141             tot_results = self._get_tot_results(results) 
    142                
    143         if filtered is None: 
    144             return Result(count, start_index, start_page, tot_results, subresult = [])  
    145                
     155 
     156    def _check_start_filter(self, startTime, phenomenonTime): 
     157        pt = phenomenonTime 
     158        if isinstance(phenomenonTime, list): 
     159            if len(phenomenonTime) == 0: 
     160                return True 
     161            pt = phenomenonTime[0] 
     162           
     163        if isinstance(pt, TM_Instant): 
     164            pt = tm_InstantToDatetime(pt)     
     165        elif hasattr(pt, 'begin'): 
     166            pt = tm_InstantToDatetime(pt.begin) 
     167             
     168        if isinstance(pt, datetime) and isinstance(startTime, date): 
     169            return pt.date() > startTime 
     170        if isinstance(pt, date) and isinstance(startTime, datetime): 
     171            return pt > startTime.date()    
     172        return pt > startTime      
     173         
     174    def _check_end_filter(self, endTime, phenomenonTime):  
     175        pt = phenomenonTime 
     176        if isinstance(phenomenonTime, list): 
     177            if len(phenomenonTime) == 0: 
     178                return True 
     179            pt = phenomenonTime[0] 
     180 
     181        if isinstance(pt, TM_Instant): 
     182            pt = tm_InstantToDatetime(pt)     
     183        elif hasattr(pt, 'end'): 
     184            pt = tm_InstantToDatetime(pt.end) 
     185         
     186        if isinstance(pt, datetime) and isinstance(endTime, date): 
     187            return endTime < pt.date() 
     188        if isinstance(pt, date) and isinstance(endTime, datetime): 
     189            return endTime.date() < pt              
     190        return endTime < pt 
     191 
     192    def apply_query_params(self, context, results): 
    146193        subresults = [] 
    147         for result in filtered: 
    148             item = None           
     194        for result in results:           
    149195            result_guid = context['moles3EPB'].retrieveGUIDFromInstance(result) 
    150196            if result_guid is None: 
    151197                continue 
    152              
    153             if context['q'] is not None: 
    154                 if not self._check_text_filter(context['q'], self._extractTitle(result), result.description): 
    155                     continue 
    156                  
    157198            ititle = self._extractTitle(result) 
    158             item = Subresult(result_guid.id, ititle, datetime.now().isoformat(), description = result.description)                
     199 
     200            kwargs = {}                 
     201            #------------------------ 
     202            phenomenonTime = result.phenomenonTime 
     203            if isinstance(result, list) and len(result.phenomenonTime) > 0: 
     204                phenomenonTime = result.phenomenonTime[0]                     
     205            kwargs['beginPosition'], kwargs['endPosition'] = \ 
     206                from_pt_to_string(phenomenonTime) 
     207            #------------------------                                                                
     208            kwargs['geometry'] = self._new_extract_geographic_extent(result) 
     209            kwargs['description'] = result.description             
     210 
     211            item = Subresult(result_guid.id, ititle, datetime.now().isoformat(),  
     212                             **kwargs)                
    159213            subresults.append(item) 
    160          
    161          
     214        return subresults 
     215 
     216    def digest_search_results(self, results, context): 
     217        if type(results) == CEDA_ObservationCollection: 
     218            results = results.member 
     219        elif type(results) == CEDA_Observation: 
     220            results = results.result 
     221        elif type(results) == CEDA_Result: 
     222            results = results.result 
     223        elif isinstance(results, _ElementInterface): 
     224            return self._digest_fatcat_atom(context, results)                     
     225 
     226        count, start_index, start_page = self._importCountAndPage(context)         
     227        # This check is a trick to speed up the response when no query parameter  
     228        # is required (all parameters are None). In this case the results are paged first  
     229        # then the subresults are generated. 
     230        # The opposite, filter first then the subresults are generated,  
     231        # if any query parameter is not None  
     232        if context['start'] is None \ 
     233            or context['stop'] is None \ 
     234            or context[BBOX] is None \ 
     235            or context['q'] is None: 
     236            filtered = filter_results(results, count, start_index, start_page)  
     237            subresults = self.apply_query_params(context, filtered)  
     238        else: 
     239            filtered = self.apply_query_params(context, results) 
     240            subresults = filter_results(filtered, count, start_index, start_page)  
     241                                             
     242        tot_results = len(subresults)         
    162243        return Result(count, start_index, start_page, tot_results, \ 
    163244                      subresult = subresults, title=HPFOS_TITLE) 
     245 
     246    def _new_extract_geographic_extent(self, result):         
     247        if not hasattr(result, 'geographicExtent') \ 
     248            or result.geographicExtent is None \ 
     249            or len(result.geographicExtent) == 0: 
     250            return None 
     251         
     252        ge = result.geographicExtent[0] 
     253        if not isinstance(ge, EX_GeographicBoundingBox): 
     254            return 
     255 
     256        return _create_box2d('%s %s' % (ge.southBoundLatitude, ge.westBoundLongitude),  
     257                             '%s %s' % (ge.northBoundLatitude, ge.eastBoundLongitude)) 
     258                                     
     259 
     260 
     261 
     262    def _extract_geographic_extent(self, result):         
     263        if not hasattr(result, 'geographicExtent') \ 
     264            or result.geographicExtent is None \ 
     265            or len(result.geographicExtent) == 0: 
     266            return None, None 
     267         
     268        ge = result.geographicExtent[0] 
     269        if not isinstance(ge, EX_GeographicBoundingBox): 
     270            return 
     271         
     272        #returns lowerCorner, upperCorner 
     273        return [ge.southBoundLatitude, ge.westBoundLongitude], \ 
     274                                    [ge.northBoundLatitude, ge.eastBoundLongitude] 
     275         
    164276         
    165277    def generateEntryLinks(self, entry, atomroot, path, linkid = None): 
     
    182294            #Here could loop over results 
    183295            atomID = createID(path + subresult.id + '/' + self.extension, root = atomroot) 
    184             ititle = createTitle(root = atomroot, body = subresult.title, itype = HTML_TYPE) 
    185             atomContent = createContent(root = atomroot, body = subresult.description, itype = HTML_TYPE) 
     296            ititle = createTitle(root = atomroot,  
     297                                 body = subresult.title,  
     298                                 itype = HTML_TYPE) 
     299            atomContent = createContent(root = atomroot,  
     300                                        body = subresult.description,  
     301                                        itype = HTML_TYPE) 
    186302            atomUpdated = createUpdated(subresult.updated, root = atomroot) 
    187             atomPublished = createPublished('TO_BE_DONE_2011-01-21T11:05:29.511Z', root = atomroot)             
     303            atomPublished = createPublished('TO_BE_DONE_2011-01-21T11:05:29.511Z',  
     304                                            root = atomroot)             
    188305            entry = createEntry(atomID, ititle, atomUpdated, 
    189306                                published=atomPublished, 
     
    191308            #xmlentry = entry.buildElement() 
    192309             
     310             
     311            beginPosition = None 
     312            endPosition = None 
     313            if hasattr(subresult, 'beginPosition') and subresult.beginPosition is not None: 
     314                beginPosition = subresult.beginPosition 
     315            if hasattr(subresult, 'endPosition') and subresult.endPosition is not None:                 
     316                endPosition = subresult.endPosition  
     317            self._append_valid_time(subresult, entry, atomroot, beginPosition, endPosition)             
     318             
    193319            idate = createDate(root = atomroot,  
    194320                               body = 'TO_BE_DONE_2002-10-18T08:07:37.387Z/2012-03-29T07:12:20.735Z')         
    195321            entry.append(idate) 
    196322             
    197             posList = createPosList(root = atomroot, body = '-90 -180 90 -180 90 180 -90 180 -90 -180', srsDimension = '2') 
    198             linearRing = createLinearRing(root = atomroot, body = posList) 
    199             exterior = createExterior(root = atomroot, body = linearRing) 
    200             polygon = createPolygon(root = atomroot, body = exterior) 
    201             where = createWhere(root = atomroot, body = polygon) 
    202             entry.append(where) 
    203             self.generateEntryLinks(entry, atomroot, path, subresult.id)             
     323            if hasattr(subresult, 'geometry') and subresult.geometry is not None: 
     324                self._append_where(subresult.geometry, entry, atomroot) 
     325             
     326            self.generateEntryLinks(entry, atomroot, path, subresult.id) 
     327            if hasattr(subresult, 'enclosure') and subresult.enclosure is not None:  
     328                for enclosure in subresult.enclosure: 
     329                    if enclosure.get('rel', None) == 'enclosure':  
     330                        entry.append(createLink(enclosure.get('href'),  
     331                                                rel = 'enclosure',  
     332                                                root = atomroot,  
     333                                                itype = enclosure.get('type'), 
     334                                                length = enclosure.get('length')))                 
     335                             
    204336            entries.append(entry) 
    205337 
    206338        for entry in entries: 
    207339            atomroot.append(entry)  
     340 
     341    def _append_where(self, geometry, entry, atomroot): 
     342        if geometry.startswith('BOX2D('): 
     343            lc, uc = geometry[6:-1].split(',') 
     344            lowerCorner = createLowerCorner(atomroot, values = lc) 
     345            upperCorner = createUpperCorner(atomroot, values = uc) 
     346            where_body = createEnvelope(lowerCorner, upperCorner, atomroot) 
     347             
     348        elif geometry.startswith('POLYGON(('): 
     349                posList = createPosList(root = atomroot,  
     350                                        values = [float(val) for val  
     351                                                  in geometry[9:-2]. 
     352                                                        replace(',', ' ').split()],  
     353                                        srsDimension = '2') 
     354                linearRing = createLinearRing(root = atomroot, body = posList) 
     355                exterior = createExterior(root = atomroot, body = linearRing) 
     356                where_body = createPolygon(root = atomroot, body = exterior)         
     357 
     358        where = createWhere(root = atomroot, body = where_body) 
     359        entry.append(where) 
     360 
     361    def _append_valid_time(self, subresult, entry, atomroot, beginPosition, endPosition): 
     362        #xmlentry = entry.buildElement() 
     363        if beginPosition is not None: 
     364            beginPosition = createBeginPosition(root = atomroot, body = subresult.beginPosition) 
     365        if endPosition is not None:                 
     366            endPosition = createEndPosition(root = atomroot, body = subresult.endPosition)                 
     367        timePeriod = createTimePeriod(root = atomroot, begin = beginPosition, end = endPosition)        
     368        validTime = createValidTime(root = atomroot, body = timePeriod) 
     369        if beginPosition is not None or endPosition is not None: 
     370            entry.append(validTime)  
    208371 
    209372    def _importCountAndPage(self, context):         
     
    272435    def do_search(self, context): 
    273436        ibbox = None 
    274         if context is not None and context.has_key(BBOX) and context[BBOX] is not None: 
     437        if context.has_key(BBOX) and context[BBOX] is not None: 
    275438            coords = context[BBOX].split(',') 
    276439            try: 
    277440                if len(coords) == 4: 
    278                     ibbox = create_st_setSRID(int(coords[0]),int(coords[1]),int(coords[2]),int(coords[3])) 
     441                    ibbox = create_st_setSRID(int(coords[0]),int(coords[1]), 
     442                                              int(coords[2]),int(coords[3])) 
    279443            except: 
    280444                pass 
    281445         
     446        if context.has_key(GUID) and 'FID' in context[GUID]: 
     447            return self._extractFatcatEntities(context[GUID]) 
     448         
    282449        if not context.has_key(GUID) or context[GUID] is None: 
    283             return context['moles3EPB'].getObservationCollections(bbox = ibbox)         
     450            return context['moles3EPB'].getObservationCollections(bbox = ibbox,  
     451                                                                  keywords = context['q'])         
    284452               
    285453        obj = context['moles3EPB'].getInstanceFromGUID(context[GUID])     
     
    287455            return None 
    288456        if type(obj) == CEDA_ObservationCollection: 
    289             return context['moles3EPB'].searchSelectiveLoadByInstance(obj, 'member') #need to add bbox & phenomTime 
     457            return context['moles3EPB'].searchSelectiveLoadByInstance(obj, 'member') 
    290458        elif type(obj) == CEDA_Observation: 
    291             #return context['moles3EPB'].searchSelectiveLoadByInstance(obj, 'result') #need to add bbox & phenomTime 
    292459            for source in obj.result.source: 
    293460                if source.function == 'search': 
     
    302469    source = get_document(host, path, port, proxy = PROXY_URL) 
    303470    return get_xml_document(source) 
     471 
     472def _create_box2d(lc, uc): 
     473    ''' 
     474        Creates a postgis-like BOX2D string. 
     475        **Parameters** 
     476            * lc: the box lower corner as a two floats-as-string space separated pair  
     477            * uc: the box upper corner as a two floats-as-string space separated pair 
     478        **Returns** 
     479            A string formatted as 'BOX2D(lc1 lc2, uc1 uc2)' 
     480    '''     
     481    return 'BOX2D(%s, %s)' % (lc, uc) 
  • mauRepo/HPFos/trunk/hpfos/HPFos/settings.py

    r8516 r8548  
    165165} 
    166166 
     167#This parameter needs to advise the code of a non_root deployment 
     168non_root_url = 'PROJECT_NAME_PAR' 
     169 
    167170os_engine = setUp() 
    168171#MOLES3_DB_CONNECTION = 'postgresql://user:pws@host:port/dbName' 
  • mauRepo/HPFos/trunk/hpfos/HPFos/urls.py

    r8516 r8548  
    1818     
    1919) 
     20iformat = ["atom", "xml"] 
     21iformats_re = '(' + '|'.join(iformat) + ')' 
     22 
     23 
    2024 
    2125urlpatterns += patterns('hpfos.HPFos.view.view', 
    22     (r'^$', 'getHome'), 
     26    (r'^$', 'get_home'), 
    2327) 
    2428 
    2529urlpatterns += patterns('hpfos.HPFos.view.view', 
    26     (r'search/description$', 'getDescription'), 
     30    (r'search/description$', 'get_description'), 
    2731) 
    2832 
    2933urlpatterns += patterns('hpfos.HPFos.view.view', 
    30     (r'search/(\w+)/$', 'doSearchL0'), 
     34    (r'search/(\w{32})/' + iformats_re + '/$', 'do_search_l1'), 
    3135) 
    3236 
    3337urlpatterns += patterns('hpfos.HPFos.view.view', 
    34     (r'search/(\w+)/description$', 'getDescription'), 
    35 ) 
    36 urlpatterns += patterns('hpfos.HPFos.view.view', 
    37     (r'search/(\w+)/(\w+)/$', 'doSearchL1'), 
     38    (r'search/' + iformats_re + '/$', 'do_search_l0'), 
    3839) 
    3940 
    4041urlpatterns += patterns('hpfos.HPFos.view.view', 
    41     (r'search/(\w+)/(\w+)/description$', 'getDescription'), 
     42    (r'search/' + iformats_re + '/description$', 'get_description'), 
    4243) 
    43 urlpatterns +=  patterns('hpfos.HPFos.view.view', 
    44     (r'search/(\w+)/(\w+)/(\w+)/$', 'doSearchL2'), 
     44urlpatterns += patterns('hpfos.HPFos.view.view', 
     45    (r'search/(\w{32}|\w{32}FID\w+)/' + iformats_re + '/$', 'do_search_l1'), 
    4546) 
    4647 
    47 urlpatterns += patterns('hpfos.HPFos.view.view', 
    48     (r'search/(\w+)/(\w+)/(\w+)/description$', 'getDescription'), 
    49 ) 
    50 urlpatterns += patterns('hpfos.HPFos.view.view', 
    51     (r'search/(\w+)/(\w+)/(\w+)/(\w+)/$', 'doSearchL3'), 
    52 ) 
     48#The first parameter is the fatcat GUID for the resource 
     49#The second paramter is the fatcat resource file_is 
     50#The third now can be only 'atom'  
     51#urlpatterns += patterns('hpfos.HPFos.view.view', 
     52#    (r'search/(\w{32})FID(\w+)/' + iformats_re + '/$', 'do_search_fatcat_file'), 
     53#) 
     54 
  • mauRepo/HPFos/trunk/hpfos/HPFos/view/view.py

    r8527 r8548  
    3131@author: Maurizio Nagni 
    3232''' 
    33 from hpfos.HPFos.settings import os_engine 
    34 from hpfos.HPFos.osImpl.myimpl import COLLECTION, OBSERVATION, RESULT, GUID,\ 
    35     DUMMY_GUID 
     33from hpfos.HPFos.settings import os_engine, non_root_url 
    3634from django.utils.safestring import mark_safe 
    3735from django.shortcuts import render_to_response 
    3836from django.core.context_processors import csrf 
    39 from ea_model.ceda_metadatamodel.ceda_observationcollection.ceda_observationcollection import CEDA_ObservationCollection 
    40 from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation import CEDA_Observation 
    4137 
    4238hostURL = 'http://localhost:8000' 
    4339 
    44 def _buildHostURL(request): 
    45     ''' 
    46         Cannot hardcode "HPFos" in the URL. This has to be fixed later 
    47     '''     
     40def _build_host_url(request): 
     41    root = '' 
     42    if non_root_url != 'PROJECT_NAME_PAR' : 
     43        root = non_root_url 
    4844    if 'localhost' in request.get_host(): 
    4945        return 'http://%s' % (request.get_host()) 
    5046     
    5147    if request.is_secure(): 
    52         return 'https://%s/HPFos' % (request.get_host()) 
     48        return 'https://%s/%s' % (request.get_host(), root) 
    5349    else: 
    54         return 'http://%s/HPFos' % (request.get_host()) 
     50        return 'http://%s/%s' % (request.get_host(), root) 
    5551 
    56 def getHome(request): 
     52def get_home(request): 
    5753    context = {} 
    58     context['hostURL'] = _buildHostURL(request) 
    59     return _dispatchResponse(request, 'homeTemplate', context) 
     54    context['hostURL'] = _build_host_url(request) 
     55    return _dispatch_response(request, 'homeTemplate', context) 
    6056 
    61 def getDescription(request, collection_guid = None, observation_guid = None, result_guid = None): 
    62     hostURL = _buildHostURL(request) 
    63     ospath = _buildDescriptionOsPath(hostURL, collection_guid, observation_guid, result_guid) 
     57def get_description(request, collection_guid = None,  
     58                   observation_guid = None,  
     59                   result_guid = None): 
     60    host_url = _build_host_url(request) 
     61    ospath = _build_description_ospath(host_url, collection_guid, observation_guid, result_guid) 
    6462    response = os_engine.get_description(ospath) 
    6563    context = {} 
    6664    context['response'] = mark_safe(response) 
    67     return _dispatchResponse(request, 'responseTemplate', context)  
     65    return _dispatch_response(request, 'responseTemplate', context)  
    6866 
    69 def _doSearch(request, iformat, guid = None, result_guid = None): 
    70     hostURL = _buildHostURL(request)    
     67def _do_search(request, iformat, **kwargs): 
     68    host_url = _build_host_url(request)    
    7169    context = os_engine.create_query_dictionary() 
    7270    if request.GET is not None: 
    7371        for param in request.GET.iteritems(): 
    7472            context[param[0]] = param[1] 
    75          
    76     context[GUID] = guid 
    77     if guid == DUMMY_GUID: 
    78         context[GUID] = None     
     73 
     74    context.update(context, **kwargs)         
    7975     
    8076    context['moles3EPB'] = request.moles3EPB 
    8177 
    82     response = os_engine.do_search(hostURL, iformat, context) 
     78    response = os_engine.do_search(host_url, iformat, context) 
    8379     
    8480    context = {} 
    8581    context['response'] = mark_safe(response) 
    86     return _dispatchResponse(request, 'responseTemplate', context) 
     82    return _dispatch_response(request, 'responseTemplate', context) 
    8783 
    88 def doSearchL0(request, iformat): 
    89     return _doSearch(request, iformat) 
     84def do_search_l0(request, iformat): 
     85    return _do_search(request, iformat) 
    9086 
    91 def doSearchL1(request, guid, iformat): 
    92     return _doSearch(request, iformat, guid) 
     87def do_search_l1(request, reference_id, iformat): 
     88    return  _do_search(request, iformat, guid = reference_id) 
    9389 
    94 def _buildDescriptionOsPath(hostURL, collection_guid = None, observation_guid = None, result_guid = None): 
     90def _build_description_ospath(hostURL, collection_guid = None, observation_guid = None, result_guid = None): 
    9591    ospath = "%s/search/" % (hostURL) 
    9692    if collection_guid: 
     
    10298    return ospath         
    10399         
    104 def _dispatchResponse(request, template, context): 
     100def _dispatch_response(request, template, context): 
    105101    context.update(csrf(request)) 
    106102    return render_to_response(template, context)     
  • mauRepo/HPFos/trunk/hpfos/tests/testsetup.py

    r8523 r8548  
    55from hpfos.HPFos.osImpl.hpfos_conf import setUp 
    66from django.test.client import RequestFactory 
     7from hpfos.libs.postgisutil import create_st_setSRID 
    78 
    89 
     
    3334    def tearDown(self): 
    3435        pass 
     36     
     37    def test_search_observation_collection(self): 
     38        res = HPFosTest.epbRepo.getObservationCollections() 
     39        ibbox = create_st_setSRID(180,-90,-180,90) 
     40        res = HPFosTest.epbRepo.getObservationCollections(bbox=ibbox) 
     41        print res 
    3542 
    3643class MyRequest(RequestFactory): 
Note: See TracChangeset for help on using the changeset viewer.