Changeset 6618 for TI01-discovery-Ingest


Ignore:
Timestamp:
24/02/10 10:03:54 (9 years ago)
Author:
sdonegan
Message:

Commit of code that updates successfully MEDIN ISO as well as GCMD DIF into NDG3 style postgres DB..

Location:
TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch/ExtractISO.py

    r6614 r6618  
    3737         
    3838        ''' 
    39         Method to map ISO values to Discovery Database columns 
     39        Method to map ISO variables to Discovery Database columns - use in PostgresDAO.py with getattr! 
    4040         
    4141        returns a dictionary where key is  
     
    5353        'metadataUpdateDate':'dataset_metadata_update_date', \ 
    5454        'dataFormat':'original_format_name'} 
    55          
     55                 
     56                 
     57        ''' 
     58                Method to match the columns found in mapIsoFieldsToDBcolumns to the postgres data types 
     59        ''' 
     60        def mapDBcolumnsToIsoDataTypes(self): 
     61                 
     62                return {'original_format_name':'text', \ 
     63        'original_format_version':'text',\ 
     64        'dataset_abstract':'text', \ 
     65        'resource_type_ts_vector':'tsvector', \ 
     66        'topic_category_ts_vector':'tsvector', \ 
     67        'lineage_ts_vector':'tsvector', \ 
     68        'limitations_public_access_ts_vector':'tsvector', \ 
     69        'data_originator':'text',\ 
     70        'dataset_metadata_update_date':'timestamp', \ 
     71        'original_format_name':'text'} 
    5672         
    5773                 
     
    147163                try: 
    148164                        self.dataOriginator= self.getElementVal(self.isoModel.dataOriginator()) 
     165                         
    149166                except: 
    150167                        self.dataOriginator = None 
     
    171188                        self.originalFormatVersion = None 
    172189                         
    173                 import pdb 
    174                 pdb.set_trace() 
    175190                 
    176191                logging.info("") 
  • TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch/PostgresDAO.py

    r6544 r6618  
    55''' 
    66import sys, os, logging, datetime 
    7 from SpatioTemporalData import * 
     7#from SpatioTemporalData import * 
    88from ndg.common.src.clients.reldb.postgres.postgresclient import PostgresClient as pgc 
    99 
     
    3535         
    3636         
    37          
     37     
    3838 
    3939    def getRecordID(self): 
     
    141141        # Now add the spatiotemporal data 
    142142        self._insertSpatioTemporalData() 
     143         
     144        #if iso original metadata format, add in additional fields         
     145        self._updateISOcolumns() 
     146         
    143147        logging.info("New record created") 
    144148        return True 
    145              
     149        
     150     
     151    def _updateISOcolumns(self): 
     152        ''' 
     153        Method to control the update of the extra ISO columns required for full MEDIN ingest 
     154        ''' 
     155         
     156        dbColumns = self.isoDataModel.mapIsoFieldsToDBcolumns() 
     157         
     158        for isoData in dbColumns.keys(): 
     159                 
     160                logging.info("Attempting to update: " + isoData) 
     161                 
     162                columnValue = getattr(self.isoDataModel,isoData) 
     163                columnName = dbColumns[isoData] 
     164                 
     165                if columnValue is not None: 
     166                        if self._updateDataBaseColumn(self._record.shortFilename, columnName, columnValue): 
     167                                logging.info("Successfully updated " + isoData) 
     168                        else: 
     169                                logging.warn("Could not update " + isoData) 
     170                else: 
     171                        logging.info(isoData + " is None - skipping") 
     172                 
     173                 
     174                 
     175     
     176    ''' 
     177    Method to update individual columns within the Discovery database based on unique id (original_document_filename, 
     178    column name and value to be inserted into that column 
     179    ''' 
     180    def _updateDataBaseColumn(self,original_document_filename,columnName,columnValue): 
     181         
     182        report = False 
     183         
     184        logging.info("Updating " + columnName + " for record: " + original_document_filename) 
     185         
     186        #get the matching dictionary of postgres datatypes defined in the iso model 
     187        postgresDataType = self.isoDataModel.mapDBcolumnsToIsoDataTypes()[columnName] 
     188         
     189        #construct the actual sql command here - easier to handle than using sql function (& to adapt!) 
     190        #remember doing it on a 1:1 basis here - convert raw multi list to space delimited value if text of tsVector 
     191        if (postgresDataType == 'tsvector') or (postgresDataType == 'text'): 
     192                 
     193                logging.info("Data type is text or tsvector!") 
     194                 
     195                if len(columnValue[0]) == 0: 
     196                        logging.info("No data to extract - no point continuing!") 
     197                        return False 
     198                 
     199                elif len(columnValue[0]) > 1: 
     200                        newColVal = "" 
     201                        for val in columnValue[0]: 
     202                                newColVal = newColVal + val 
     203                                 
     204                else: 
     205                        newColVal = columnValue[0][0] 
     206                         
     207        else: 
     208                logging.info("Data type not text or vector!") 
     209                 
     210                if len(columnValue[0]) > 1: 
     211                        logging.warn("NOTE: " + columnName + " is attempting to add multiple values - just take first for now!") 
     212                        newColVal = columnValue[0][0] 
     213                else: 
     214                        newColVal = columnValue[0][0] 
     215                 
     216                #TODO: at some stage add some checking of timestamps etc 
     217         
     218        #build the sql query 
     219        #i.e. update original_document set original_format_version = 'dooby' where original_document_filename = 'dooby.ac.uk.shgfhf.xml' 
     220        if postgresDataType == 'tsvector': 
     221                sqlCmd = "update original_document set " + columnName + " = to_tsvector('english','" + newColVal + "') where original_document_filename = '" + original_document_filename + "';" 
     222         
     223        else: 
     224                sqlCmd = "update original_document set " + columnName + " = '" + newColVal + "' where original_document_filename = '" + original_document_filename + "';" 
     225         
     226        #submit the sqlQuery 
     227        try: 
     228                sqlCmd = sqlCmd.replace("'null'", "null") 
     229                sqlCmd = sqlCmd.replace("'None'", "null") 
     230                sqlCmd = sqlCmd.replace("None", "null") 
     231                 
     232                self.pgc.runSQLCommand(sqlCmd) 
     233                 
     234                report = True 
     235        except: 
     236                logging.error("Could not submit query for: " + sqlCmd) 
     237                 
     238         
     239        return report 
     240         
     241         
    146242 
    147243    def updateRecord(self): 
     
    170266            self._insertSpatioTemporalData() 
    171267            result = True 
    172  
     268             
     269            #if iso original metadata format, add in additional fields  
     270            self._updateISOcolumns() 
     271         
    173272        logging.info("Finish processing document...") 
    174273         
     
    417516            #if docType is original input xml then put that in rather than some lossy transformed guff. 
    418517            if docType == self._record.docType: 
    419                 doc = self.originalXMLdoc              
     518                doc = self._record.originalXMLdoc              
    420519             
    421520            sqlCmd = "UPDATE TRANSFORMED_DOCUMENT SET transformed_document = '" + doc + \ 
  • TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch/PostgresRecord.py

    r6544 r6618  
    1111import ndg.common.src.lib.fileutilities as FileUtilities 
    1212from Utilities import xqueryTransformation 
    13 from SpatioTemporalData import SpatioTemporalData 
     13#from SpatioTemporalData import SpatioTemporalData 
    1414import keywordAdder 
    1515 
     
    6565        # simplify processing by uppercasing format at initialisation 
    6666        self.docType = docType.upper()     
    67                 
     67         
    6868        #make sure we escape any special characters in this field... SJD 20/10/09         
    6969        #self.dataset_name = self.escapeSpecialCharacters(self.isoDataModel.datasetName[0]) 
     
    7272        self.datacentre_name = self.isoDataModel.datacentreName[0][0] 
    7373         
    74         #self.dataset_lastEdit = datasetLastEditUpdateDate     
     74        #self.dataset_lastEdit = datasetLastEditUpdateDate 
    7575        self.dataset_lastEdit = self.isoDataModel.revisionDate[0][0] 
    76                  
     76             
    7777        #self.datasetStartNom = datasetStartDateNom 
    7878        self.datasetStartNom = self.isoDataModel.boundingDatesRange['start'] #dictionary method! 
     
    122122        self._saxonJarFile = saxonJarFile 
    123123         
    124         self.stubISO = self.escapeSpecialCharacters(stubIso) 
     124         
    125125        self.originalXMLdoc = self.escapeSpecialCharacters(originalXML) 
     126         
     127        #need t define stubISO only if ingesting a dif. 
     128        if self.originalXMLdoc == "null": 
     129             self.stubISO = None 
     130        else: 
     131                self.stubISO = self.escapeSpecialCharacters(stubIso) 
    126132         
    127133         
     
    209215         
    210216        self.discovery_dir = transformationDir 
     217         
    211218                 
    212219        for docType in self._xqueryConversions: 
     
    219226        if self.stubISO is not None: 
    220227                logging.info("Transient ISO intermediate format detected; adding to transformed docs!") 
     228                 
    221229                self._allDocs.append(['stubISO',self.stubISO]) 
    222         
     230                 
     231        else: 
     232                 
     233                #if not DIF, put original format ISO in here 
     234                #TODO - put in version with redirected URLs?? 
     235                self._allDocs.append([self.docType,self.originalFormat]) 
    223236        
    224237        return self._allDocs 
     
    282295        logging.info("Extracting author info") 
    283296         
    284         #simple method to generate a space delimited list of authors from isoObject 
    285          
     297        #simple method to generate a space delimited list of authors from isoObject         
    286298        self.authors = '' 
    287299         
    288300        #remember the double list return style.. 
    289         if self.isoDataModel.authors[0][0] == 'None': 
     301        if len(self.isoDataModel.authors[0])==0: 
     302                logging.info("No author information present (none not caught but extractISO.py - sort it!") 
     303                self.authors = "null" 
     304                return self.authors 
     305                 
     306        if self.isoDataModel.authors[0][0] == 'None':            
    290307                logging.info("No author information present") 
     308                self.authors = "null" 
    291309        else: 
    292310                for author in self.isoDataModel.authors[0]: 
     
    322340         
    323341        #TODO - put this in configuration file! 
    324         acceptedScopeVals = ['NERC_DDC','DDDP','MEDIN'] 
     342        acceptedScopeVals = ['NERC_DDC','DDDP','MEDIN','NDGO0001'] 
    325343         
    326344        scopeVals = self.isoDataModel.keywordsList 
     
    330348        for keyword in scopeVals: 
    331349                if keyword in acceptedScopeVals: 
     350                         
     351                        #deal with MEDIN using NDGO0001 as MEDIN scope val 
     352                        if keyword == 'NDGO0001': 
     353                                keyword = 'MEDIN' 
     354                                 
    332355                        scope += " " + keyword 
    333356                 
  • TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch/Utilities.py

    r6544 r6618  
    286286                 
    287287                xquery = self.xqueryLib.createXQuery(self.xQueryType,self.metadataFileLoc, self._repository_local_id, self._local_id) 
    288        
     288                 
     289                 
    289290                # sort out the input ID stuff                            
    290291                xquery=xquery.replace('Input_Entry_ID', self.discovery_id) 
  • TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch/abstractdocumentingester.py

    r6544 r6618  
    2323import inspect 
    2424 
    25 #temp 
    26 from AbstractFormatIngester_original import AbstractFormatIngesterOriginal 
    27  
    2825class AbstractDocumentIngester(object): 
    2926        ''' 
     
    145142                shortFilename = filename.split('/')[numSlash - 1] 
    146143                 
    147                 self.recordAttemptToIngestDiscoveryID = ""                               
     144                self.recordAttemptToIngestDiscoveryID = "" 
     145                 
     146                #need to generate a local version of the iso data model (first call was to run through all available files 
     147                #and convert & place into relevant dirs as necessary 
     148                #generate the ISO object from the converted ISO here now.. 
     149                 
     150                try: 
     151                                                                                                 
     152                        self.isoDataModel = ExtractISO(filename,self._isoClass[self._datacentre_format]) 
     153                                 
     154                        if self.isoDataModel.createISOdataStructure() is True: 
     155                                logging.info("ISO extractor worked fine!") 
     156                         
     157                         
     158                        elif self.isoDataModel.createISOdataStructure() is True: 
     159                                logging.error ("Something wrong with ISO extractor... (ExtractISO returned False: xml access problem?)")                         
     160                                                #sys.exit() # TODO fix these 
     161                                return 
     162                        else: 
     163                                logging.error("Something SERIOUSELY wrong with extractor (couldnt get at ExtractISO class)")                     
     164                                                #sys.exit() 
     165                                return 
     166                except: 
     167                        logging.error("Could not generate ISO XML!") 
     168                        return 
     169                                 
    148170                 
    149171                # first of all create a PostgresRecord - this object represents all the data required 
     
    152174                 
    153175                try: 
    154                          
    155                         #set up iso xml object - format indicatees the ISO profile (including dif2iso conversions)                                               
    156                         self.isoDataModel = ExtractISO(filename,self._isoClass[self._datacentre_format]) 
    157                          
    158                          
    159                         if self.isoDataModel.createISOdataStructure() is True: 
    160                                 logging.info("ISO extractor worked fine!") 
    161                          
    162                          
    163                         elif self.isoDataModel.createISOdataStructure() is True: 
    164                                 logging.error ("Something wrong with ISO extractor... (ExtractISO returned False: xml access problem?)")                         
    165                                 #sys.exit() # TODO fix these 
    166                                 return 
    167                         else: 
    168                                 logging.error("Something SERIOUSELY wrong with extractor (couldnt get at ExtractISO class)")                     
    169                                 #sys.exit() 
    170                                 return 
    171176                                 
    172177                        #record whats bout to be ingestd 
    173178                        self.recordAttemptToIngestDiscoveryID = self.isoDataModel.datasetID[0][0] 
    174                          
     179                                                 
    175180                        #In new ingest system all vals parsed from iso xml are returned as either lists of dictionaries 
    176181                         
     
    456461                                 
    457462                                #if DIF still need to convert URL's using the old method so when requesting DIF in original format we still have correct redirect urls.... 
    458                                 redirectUrlChanger(original_filename,original_filename,self._datacentre_format, self._ndgRedirectURL) 
     463                                #redirectUrlChanger(original_filename,original_filename,self._datacentre_format, self._ndgRedirectURL) 
    459464                                                                                                                 
    460465                                #gets the metadata id from the xml 
     
    472477                                self.isoFormat= "stubISO" 
    473478                                                                 
     479                                                                 
    474480                                #self.isoXML = self.convertDIFtoISO(metadataFileLoc,repositoryName,metadataID,metadataFilename) 
    475481                                self.xqueryTransformation = xqueryTransformation(metadataFileLoc,repositoryName,metadataID,metadataFilename,self._saxonJarFile) 
    476                                  
    477                                 #get hold of the xml for the transformed ISO 
     482                                                                                                                         
     483                                #get hold of the xml for the transformed ISO                             
    478484                                self.isoXML = self.xqueryTransformation.runXquery(self._dif2isoXquery) 
    479                                  
     485                                                                 
     486                                #create the iso file on the system 
     487                                tempStubISOfile = original_filename + ".stubISO.xml" 
     488                                FileUtilities.createFile(tempStubISOfile , self.isoXML) 
     489                                 
     490                                #generate the ISO object from the converted ISO here now.. 
     491                                try: 
     492                                                                                                 
     493                                        isoDataModel = ExtractISO(tempStubISOfile,self._isoClass[self._datacentre_format]) 
     494                                 
     495                                        if isoDataModel.createISOdataStructure() is True: 
     496                                                logging.info("ISO extractor worked fine!") 
     497                         
     498                         
     499                                        elif isoDataModel.createISOdataStructure() is True: 
     500                                                logging.error ("Something wrong with ISO extractor... (ExtractISO returned False: xml access problem?)")                         
     501                                                #sys.exit() # TODO fix these 
     502                                                return 
     503                                        else: 
     504                                                logging.error("Something SERIOUSELY wrong with extractor (couldnt get at ExtractISO class)")                     
     505                                                #sys.exit() 
     506                                                return 
     507                                except: 
     508                                        logging.error("Could not generate ISO XML!") 
     509                                        return 
     510                                 
     511                                                                 
    480512                                #need to get hold original format XML too (so can put directly into "transformed" docs section... 
    481513                                self.originalXMLdoc = '' 
     
    496528                                        new_filename_short = self._datacentre_namespace + "__" + self.isoFormat + "__" + metadataFilename.replace(":", "-")+".xml" 
    497529                                 
     530                                         
    498531                                else: 
    499                                  
     532                                        ident = isoDataModel.datasetID[0][0] 
     533                                         
    500534                                        ident = ident.replace(":", "-") 
    501535                                        ident = ident.replace("/", "-") 
     
    504538                                        new_filename_short = self._datacentre_namespace+ "__"+ self.isoFormat + "__"+ ident +".xml" 
    505539                                 
     540                                         
    506541                                 
    507542                                #now create this stub ISO file on system so can access it 
    508                                 self.stubIsoFile = discovery_dir + new_filename_short    
    509                                                                  
    510                                 FileUtilities.createFile(self.stubIsoFile, self.isoXML) 
    511                                  
    512                                 logging.info("Stub ISO file created - at %s" %discovery_dir) 
    513                                  
     543                                self.genIsoFile = discovery_dir + new_filename_short     
     544                                                                 
     545                                #FileUtilities.createFile(self.stubIsoFile, self.isoXML) 
     546                                #generate the redirect urls - now we have worked out the full discovery ndg name..  
     547                                 
     548                                isoDataModel.generateNDGredirectURL(self._ndgRedirectURL,self.genIsoFile) 
     549                                 
     550                         
    514551                         
    515552                        #all other ISO formats/profiles to deal with. 
     
    517554                                isoFormat = format 
    518555                                 
     556                                self.originalXMLdoc = "null" 
     557                                 
     558                                 
     559                                #generate the ISO object from the ISO xml..                                                                              
     560                                isoDataModel = ExtractISO(original_filename,self._isoClass[self._datacentre_format]) 
     561                                 
     562                                if isoDataModel.createISOdataStructure() is True: 
     563                                                logging.info("ISO extractor worked fine!") 
     564                         
     565                                elif isoDataModel.createISOdataStructure() is True: 
     566                                        logging.error ("Something wrong with ISO extractor... (ExtractISO returned False: xml access problem?)")                         
     567                                                #sys.exit() # TODO fix these 
     568                                        return 
     569                                else: 
     570                                        logging.error("Something SERIOUSELY wrong with extractor (couldnt get at ExtractISO class)")                     
     571                                                #sys.exit() 
     572                                        return 
     573                                 
    519574                                #Back to main stream of ISO ingest 
    520575                                if self._NDG_dataProvider: 
     
    525580                                 
    526581                                else: 
     582                                         
     583                                        ident = isoDataModel.datasetID[0][0] 
    527584                                 
    528585                                        ident = ident.replace(":", "-") 
     
    532589                                        new_filename_short = self._datacentre_namespace+ "__"+ isoFormat + "__"+ ident +".xml" 
    533590                                 
    534                                  
     591                                #now create this stub ISO file on system so can access it 
     592                                self.genIsoFile = discovery_dir + new_filename_short     
     593                                 
     594                                #generate the redirect urls - now we have worked out the full discovery ndg name..  
     595                                isoDataModel.generateNDGredirectURL(self._ndgRedirectURL,self.genIsoFile) 
     596                                 
     597                                #get the converted ISO into a local var 
     598                                try: 
     599                                        logging.info("Extracting converted ISO file into variable for input into original format in transformed docs table") 
     600                                        self.isoXML = file(self.genIsoFile).read() 
     601                                        self.originalXMLdoc = self.isoXML 
     602                                         
     603                                except: 
     604                                        logging.warn("Could not extract converted ISO xml to local variable!") 
     605                                        self.isoXML = '' 
     606                                         
    535607                        logging.info("original file = " + original_filename) 
    536608                        logging.info("newfile = " + new_filename) 
     
    627699                numfilesproc = self._convertIngestFiles(self.originals_dir, self.discovery_dir, format) 
    628700                 
    629                  
    630701                filenames = os.listdir(self.discovery_dir) 
    631702                                 
     
    648719                 
    649720                for filename in filenames: 
     721                         
    650722                        fullPath = self.discovery_dir + filename 
    651723                         
    652724                        if os.path.isfile(fullPath): 
    653                                                  
    654                                 logging.info("********************************************************************** sjd1 " + fullPath) 
    655                                                  
     725                                         
    656726                                thisIngestedID = self.addFileToPostgresDB(fullPath) 
    657                                  
    658                                 logging.info("********************************************************************** sjd2 " + thisIngestedID) 
    659727                                 
    660728                                #remove this filename from the list of files for this DC already in list (whats left over is to be deleted)  
  • TI01-discovery-Ingest/trunk/v4n_MEDIN/ingestAutomation-upgrade/OAIBatch/testISO.py

    r6451 r6618  
    3030#dif2stubIso_file = 'data/NEODC/stub_iso/neodc.nerc.ac.uk__stubISO__dataent_11658383444211836_DIF_multiDate.xml' 
    3131#dif2stubIso_file = 'data/NEODC/stub_iso/neodc.nerc.ac.uk__stubISO__dataent_11658383444211836_DIF_multiCoord.xml' 
    32 dif2stubIso_file = 'data/NEODC/stub_iso/neodc.nerc.ac.uk__stubISO__dataent_11658383444211836_DIF.xml' 
     32#dif2stubIso_file = 'data/NEODC/stub_iso/neodc.nerc.ac.uk__stubISO__dataent_11658383444211836_DIF.xml' 
    3333 
    34 isoData = ExtractISO(dif2stubIso_file,'dif2stubIso') 
     34inputISO = 'data/MEDIN/ISO_19139_Dataset_DASSH_v1.0.xml' 
     35 
     36#test dif 2 iso 
     37#isoData = ExtractISO(dif2stubIso_file,'difConvertedto_ISO19139') 
     38 
     39#test medin iso extractor 
     40isoData = ExtractISO(inputISO,'medin_2_3_ISO19139') 
    3541 
    3642 
     
    7177name = "createDate" 
    7278accessIsoDataModel(isoData.createDate, name) 
     79 
     80print "\nTesting for publication date (List) ..." 
     81name = "publicationDate" 
     82accessIsoDataModel(isoData.publicationDate, name) 
    7383         
    7484print "\nTesting for dataset name (List) ..." 
     
    8696print "\nTesting for authors (List) ..." 
    8797name = "authors" 
     98 
    8899accessIsoDataModel(isoData.authors, name) 
    89100                 
Note: See TracChangeset for help on using the changeset viewer.