Changeset 7725 for TI01-discovery-Ingest


Ignore:
Timestamp:
12/11/10 15:10:35 (9 years ago)
Author:
sdonegan
Message:

Updates to allow proper handling of NERC DMS format and uprated dif2iso conversion

Location:
TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch
Files:
1 added
7 edited

Legend:

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

    r7457 r7725  
    33import logging,urllib,os,sys,inspect 
    44from Utilities import IsoIngestListUtilities # so can use those useful getSingleVal and getMultipleVal methods for discerning lists etc (esp useful when using the isoVal to dbColumn methods..) 
     5import ndg.common.src.lib.utilities as ndgUtilities 
     6import random 
    57 
     8 
     9''' 
     10ExtractISO handler class designed to deal with NERC DMS series of ISO profile metadata (for NERC Revitilisation work) 
     11''' 
     12error='' 
     13message=''       
    614 
    715class ExtractISO: 
     
    127135                #get all the required information from the chosen xpath definition class 
    128136                self.datasetID = self.getElementVal(self.isoModel.datasetID()) 
     137                 
    129138                if self.datasetID == 'None': 
    130139                        self.processingMsg = 'No entry for Dataset ID so record not valid and cannot/will not Ingest!' 
    131140                        logging.error(self.processingMsg) 
     141                         
     142                        #to aid proper filename reporting must give it a quasi id as will give "None" filename! 
     143                        id = [str(random.randrange(1000,20000,3)) + '_ingestIempID'] # remember must be in that double list format! 
     144                        logging.info("Using random integer: %s for ID to complete reporting process..." %id) 
     145                        self.datasetID = [id] 
    132146                        self.validDoc = False 
    133147                 
    134148                else: 
     149                         
    135150                        #noticed some MEDIN centres allowing space characters in a unique id.. change to single underscore! (remember only 1 allowed!) 
    136                         self.datasetID[0][0] = self.datasetID[0][0].replace(" ", "_") 
     151                        self.datasetID[self.findTheListData(self.datasetID)][0] = self.datasetID[self.findTheListData(self.datasetID)][0].replace(" ", "_") 
    137152                 
    138153                 
     
    143158                        self.validDoc = False 
    144159                 
    145                 self.datasetAbstract = self.getElementVal(self.isoModel.dataSetAbstract()) 
     160                self.datasetAbstract = self.getElementVal(self.isoModel.dataSetAbstract())                       
    146161                 
    147162                self.revisionDate = self.getElementVal(self.isoModel.metadataRevisionDate()) 
     
    156171                                         
    157172                self.originalFormat = self.getElementVal(self.isoModel.originalFormat()) 
    158                  
    159                  
     173                                 
    160174                try: 
    161175                        self.dataFormats = self.getElementVal(self.isoModel.dataFormats()) 
     
    202216                 
    203217                self.keywordsList = self.listify(self.keywords) 
     218                 
    204219                 
    205220                if self.keywords == 'None': 
     
    264279                #updated for NERC API v4.3.0 
    265280                 
    266                 #resource locator 
     281                #resource locator                
    267282                try: 
    268283                        self.resourceLocator = self.getElementVal(self.isoModel.resourceLocator()) 
    269                         self.resourceLocator_text = self.lineage 
    270                         self.resourceLocator_tsvector = self.lineage 
     284                        self.resourceLocator_text = self.resourceLocator 
     285                        self.resourceLocator_tsvector = self.resourceLocator 
    271286                except: 
    272287                        self.resourceLocator = None 
     
    274289                        self.resourceLocator_tsvector = None 
    275290                         
    276                 #resourceLocator in the db is a boolean field - it either has a data resource or it doesnt 
    277                  
     291                #resourceLocator in the db is a boolean field - it either has a data resource or it doesnt               
    278292                if self.resourceLocator is None or self.resourceLocator =='': 
    279293                        self.resourceLocatorBool = False 
     
    298312                        self.inspireThemes_tsvector = self.inspireThemes_text 
    299313                 
    300                 #vertical extent (sub class of keywords)                 
    301                  
     314                #vertical extent (sub class of keywords)        OPTIONAL for NERC DMS                    
    302315                try: 
    303316                        self.verticalExtent = self.getElementVal(self.isoModel.verticalExtentKeyword())  
     
    358371                        self.dataOriginator_tsvector = None 
    359372                         
    360                          
     373                 
    361374                #check presence of originator - Mandatory! 
    362375                if self.dataOriginator == 'None' or self.dataOriginator is None: 
    363                         self.processingMsg = 'No entry for Data Originator so record not valid and cannot/will not Ingest!' 
    364                         logging.error(self.processingMsg) 
     376                        #self.processingMsg = 'No entry for Data Originator!' 
     377                        #logging.error(self.processingMsg) 
    365378                        #self.validDoc = False 
     379                        self.dataOriginator_text = 'null' 
     380                        self.dataOriginator_tsvector = 'null' 
    366381                 
    367382                else:                    
     
    509524                if boundingDatesList == 'None': 
    510525                        return 'None' 
    511                  
    512                          
    513                          
     526                                         
    514527                #remember, need to sort out whether there was a start and end date in the first place, or just one so can copy values over 
    515528                if len(boundingDatesList) == 1: 
     
    517530                        returnDates['start'] = boundingDatesList[0]['start'] 
    518531                        returnDates['end'] = boundingDatesList[0]['end'] 
    519                          
    520532                         
    521533                         
     
    563575                 
    564576                ''' 
    565                 MEDIN Profile v2.3 (date? - MEDIN upgrade dev) 
     577                ISO Profile version (date? - MEDIN upgrade dev) 
    566578                ''' 
    567579                 
    568580                logging.info("Format chosen: " + format) 
    569                  
    570                  
    571581                 
    572582                #Dynamically import module of correct profile... 
     
    10271037                 
    10281038                isoNs = {'gmd':'http://www.isotc211.org/2005/gmd','gco':'http://www.isotc211.org/2005/gco', 
    1029                                 'gmx':'http://www.isotc211.org/2005/gmx','gml':'http://www.opengis.net/gml/3.2', 
     1039                                'gmx':'http://www.isotc211.org/2005/gmx','gml':'http://www.opengis.net/gml', 
    10301040                                'none':'','gts':'http://www.isotc211.org/2005/gts','gsr':'http://www.isotc211.org/2005/gsr', 
    1031                                 'gss':'http://www.isotc211.org/2005/gss' 
     1041                                'gss':'http://www.isotc211.org/2005/gss','srv':'http://www.isotc211.org/2005/srv' 
    10321042                                } 
    10331043                 
     
    11581168                 
    11591169                return nameSpaceAppendedPath 
     1170         
     1171         
     1172        ''' 
     1173        Method to find which of the lists actually has data in it 
     1174        ''' 
     1175        def findTheListData(self,xpathExtraction): 
     1176                 
     1177                cnt = 0 
     1178                mapping = [] 
     1179                 
     1180                         
     1181                for subList in xpathExtraction: 
     1182                        subListLen = len(subList) 
     1183                        if subListLen > 0: 
     1184                                #found where the data is, return sublist                                 
     1185                                mapping.append(cnt)      
     1186                        cnt += 1                         
     1187                                                                 
     1188                #how many values are there 
     1189                if len(mapping) == 1: 
     1190                        return mapping[0] 
     1191                else: 
     1192                        logging.warn("More than 1 value available - for now, have taken the first!") 
     1193                        return mapping[0] 
     1194                 
     1195                 
     1196         
     1197         
     1198         
  • TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch/Metadata_document_ingester.py

    r7467 r7725  
    130130                self.getConfigDetails(dataCentre) 
    131131                 
     132                 
    132133                # override default settings with input keyword values, if set 
    133134                if harvestDir: 
  • TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch/PostgresDAO.py

    r7457 r7725  
    88from ndg.common.src.clients.reldb.postgres.postgresclient import PostgresClient as pgc 
    99 
     10 
    1011class PostgresDAO: 
    1112     
    12     def __init__(self, record, isoDataModel,transformationDir, pgClient = None): 
     13    def __init__(self, record, isoDataModel,transformationDir, pgClient = None, dpwsID = None): 
    1314        ''' 
    1415        Constructor - to initialise the DAL and do some initial setting up 
     
    3334        self.isoDataModel = isoDataModel         
    3435        self.discovery_dir = transformationDir 
     36        self.dpwsID = dpwsID 
     37         
     38        self.processingWarning = '' 
     39         
    3540         
    3641         
     
    160165        dbColumns = self.isoDataModel.mapIsoFieldsToDBcolumns() 
    161166         
     167        processingMessage = '' 
     168         
    162169        for isoData in dbColumns.keys(): 
    163170                 
    164                 logging.info("Attempting to update: " + isoData) 
    165                  
    166                  
    167                  
    168                                          
     171                logging.info("Attempting to update: " + isoData)                                 
     172                                         
    169173                columnValue = getattr(self.isoDataModel,isoData) 
    170174                columnName = dbColumns[isoData] 
    171175                 
    172                  
    173                  
    174176                if columnValue is not None: 
    175                         if self._updateDataBaseColumn(self._record.shortFilename, columnName, columnValue): 
     177                        updateReport,updateMessage = self._updateDataBaseColumn(self._record.shortFilename, columnName, columnValue) 
     178                         
     179                        if updateReport: 
    176180                                logging.info("Successfully updated " + isoData) 
     181                                 
     182                                if updateMessage != '': 
     183                                        logging.info("Processing warning: %s" %updateMessage) 
     184                                        processingMessage = '[' + columnName +']: ' + updateMessage + "\n" 
     185                                         
    177186                        else: 
    178187                                logging.warn("Could not update " + isoData) 
    179188                else: 
    180189                        logging.info(isoData + " is None - skipping") 
     190         
     191        if processingMessage != '': 
     192                self.processingWarning = processingMessage 
    181193                 
    182194                 
     
    190202         
    191203        report = False 
     204        reportMsg = '' 
    192205         
    193206        logging.info("Updating " + columnName + " for record: " + original_document_filename) 
    194                          
    195         #if columnName == 'resource_locator': 
    196         #               import pdb 
    197         #               pdb.set_trace()          
    198          
     207                                 
    199208        #get the matching dictionary of postgres datatypes defined in the iso model 
    200209        postgresDataType = self.isoDataModel.mapDBcolumnsToIsoDataTypes()[columnName] 
     
    205214                 
    206215                logging.info("Data type is text or tsvector!") 
    207                  
    208                  
     216                                 
    209217                #need to work out whether value passed here to be updated is a string or list 
    210218                if type(columnValue) is list: 
     
    212220                        if len(columnValue[0]) == 0: 
    213221                                logging.info("No data to extract - no point continuing!") 
    214                                 return False 
     222                                return False,reportMsg 
    215223                          
    216224                        elif len(columnValue[0]) > 1: 
     
    227235                          
    228236                        else: 
    229                                 #get rid of any special characters 
    230                                 newColVal = self._record.escapeSpecialCharacters(columnValue[0][0]) 
     237                                #test & get rid of any special characters - but flag it up for ingest report 
     238                                #newColVal = self._record.escapeSpecialCharacters(str(columnValue[0][0])) 
     239                                 
     240                                newColVal,reportMsg = self._record.characterEncoding(columnValue[0][0]) 
     241                                 
     242                                newColVal = self._record.escapeSpecialCharacters(newColVal) 
    231243                                 
    232244                else: 
     
    234246           
    235247                        #remaining type to deal with is the value has already been converted to a simple string (i.e. authors, data centre name) 
    236                         newColVal = self._record.escapeSpecialCharacters(columnValue) 
     248                        #newColVal = self._record.escapeSpecialCharacters(columnValue) 
     249                        newColVal,reportMsg = self._record.characterEncoding(columnValue)                                                
     250                        newColVal = self._record.escapeSpecialCharacters(newColVal) 
     251                         
     252                 
    237253                 
    238254        elif postgresDataType == 'boolean': 
     
    275291                 
    276292                #sort out escape chars from previous catches (i.e. parameters) 
    277                 sqlCmd = sqlCmd.replace("\\'","\'")              
    278                  
     293                #sqlCmd = sqlCmd.replace("\\'","\'")             
     294                                 
    279295                self.pgc.runSQLCommand(sqlCmd) 
    280296                 
     
    285301                 
    286302         
    287         return report 
     303        return report,reportMsg 
    288304         
    289305         
     
    496512        
    497513        sqlCmd = "SELECT create_document('" + self._record.shortFilename + "', '" + \ 
    498             self._record.discovery_id + "', '" + self._record.docType + "', '" + \ 
     514            self._record.discovery_id + "', '" + self.dpwsID + "', '" + self._record.docType + "', '" + \ 
    499515            self._record.originalFormat + "', '" + self._record.getAuthorsInfo() + "', '" + \ 
    500             self._record.getParametersInfo() + "', '" + self._record.getScopeInfo() + "', '" + \ 
     516            self._record.escapeSpecialCharacters(self._record.getParametersInfo()) + "', '" + self._record.getScopeInfo() + "', '" + \ 
    501517            self._record.dataset_name + "', '" + self._record.datacentre_name + "', '" + \ 
    502             self._record.dataset_lastEdit + "', '" + self._record.datasetStartNom + "', '" + self._record.datasetEndNom + "');" 
    503          
    504         
     518            self._record.dataset_lastEdit + "', '" + self._record.datasetStartNom + "', '" + self._record.datasetEndNom + "' );" 
     519         
     520         
    505521        #sort out any nulls.. 
    506522        sqlCmd = sqlCmd.replace("'NULL'","NULL") 
     523        sqlCmd = sqlCmd.replace("'null'","null") 
    507524         
    508525        #sort out any Nones 
     
    537554        logging.info("Updating original document in Postgres DB") 
    538555        sqlCmd = "SELECT update_document('" + str(self._record.db_id) + "', '" + \ 
    539             self._record.shortFilename + "', '" + \ 
     556            self._record.shortFilename + "', '" + self.dpwsID + "', '" +\ 
    540557            self._record.discovery_id + "', '" + self._record.docType + "', '" + \ 
    541558            self._record.originalFormat + "', '" + self._record.getAuthorsInfo() + "', '" + \ 
    542             self._record.getParametersInfo() + "', '" + self._record.getScopeInfo() + "', '" + \ 
     559            self._record.escapeSpecialCharacters(self._record.getParametersInfo()) + "', '" + self._record.getScopeInfo() + "', '" + \ 
    543560            str(self._record.scn) + "', '" + self._record.dataset_name + "', '" + self._record.datacentre_name + \ 
    544561            "', '" + self._record.dataset_lastEdit + "', '" + self._record.datasetStartNom + "', '" + \ 
    545562            self._record.datasetEndNom + "');"  
    546563             
     564             
     565                 
    547566         
    548567        #sort out any NULL values" 
     
    575594         
    576595        #for docType, doc in self._record.getAllDocs(self.discovery_dir):         
    577         metadataDocs = self._record.getAllDocs(self.discovery_dir)         
    578                  
     596        metadataDocs = self._record.getAllDocs(self.discovery_dir)        
     597                         
    579598        for docType in metadataDocs.keys(): 
    580599                                 
     
    583602            #fudge! 
    584603            if docType == 'DIF_9.4': 
    585                 doc = self._record.escapeSpecialCharacters(metadataDocs[docType]) 
     604                                 
     605                #don't need to escape special characters again -as dealt with when getAllDocs was called.. 
     606                #doc = self._record.escapeSpecialCharacters(str(metadataDocs[docType])) 
     607                doc = metadataDocs[docType] 
     608                 
     609                 
    586610            else: 
    587                 doc = metadataDocs[docType] 
     611                doc = str(metadataDocs[docType]) 
    588612                                                 
    589613            sqlCmd = "INSERT INTO TRANSFORMED_DOCUMENT (transformed_document_id, " \ 
     
    595619             
    596620            #print "\n\n\n%s\n\n\n" %sqlCmd 
    597          
    598              
     621            
    599622            self.pgc.runSQLCommand(sqlCmd) 
    600623         
     
    619642                logging.info("Updating metadata of type %s" %docType) 
    620643                 
    621                 sqlCmd = "UPDATE TRANSFORMED_DOCUMENT SET transformed_document = '" +  metadataDocs[docType] + "', update_date = current_timestamp WHERE original_document_id = " + str(self._record.db_id) + " AND transformed_format = '" + docType + "';" 
     644                sqlCmd = "UPDATE TRANSFORMED_DOCUMENT SET transformed_document = '" +  self._record.escapeSpecialCharacters(metadataDocs[docType]) + "', update_date = current_timestamp WHERE original_document_id = " + str(self._record.db_id) + " AND transformed_format = '" + docType + "';" 
    622645                 
    623646                self.pgc.runSQLCommand(sqlCmd) 
  • TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch/PostgresRecord.py

    r7286 r7725  
    99from ndg.common.src.lib.ndgresources import ndgResources 
    1010import ndg.common.src.lib.fileutilities as FileUtilities 
     11import ndg.common.src.lib.utilities as ndgUtilities 
    1112from Utilities import xqueryTransformation,IsoIngestListUtilities 
    1213import keywordAdder 
     
    3738                  
    3839        logging.info("Setting up Postgres record for file, " + filename) 
    39                  
     40         
     41            
    4042        self.isoDataModel = isoDataModel 
    4143         
    4244        self.filename = self.isoDataModel.isoFileLocation 
    43      
    44          
    45         #note method of extracting info from isoDataModel - nested lists, so if one value then use [0][0] 
    46         discovery_id = self.isoDataModel.datasetID[0][0] 
     45         
     46        #note method of extracting info from isoDataModel - nested lists, so if one value then use [0][0]        
     47        discovery_id = self.isoDataModel.datasetID[self.isoDataModel.findTheListData(self.isoDataModel.datasetID)][0] 
    4748     
    4849        # NB, if we're dealing with an NDG data provider, the details are slightly different 
     
    6667        #self.dataset_name = self.escapeSpecialCharacters(self.isoDataModel.datasetName[0]) 
    6768         
    68         self.dataset_name = self.escapeSpecialCharacters(self.isoDataModel.datasetName[0][0]) 
     69        self.dataset_name = self.escapeSpecialCharacters(self.isoDataModel.datasetName[self.isoDataModel.findTheListData(self.isoDataModel.datasetName)][0]) 
    6970         
    7071        self.dcOb = IsoIngestListUtilities(self.isoDataModel.datacentreName,True) 
     
    7576             
    7677        #self.datasetStartNom = datasetStartDateNom 
    77         self.datasetStartNom = self.isoDataModel.boundingDatesRange['start'] #dictionary method! 
     78        if self.isoDataModel.boundingDatesRange != 'None': 
     79                self.datasetStartNom = self.isoDataModel.boundingDatesRange['start'] #dictionary method! 
     80                self.datasetEndNom = self.isoDataModel.boundingDatesRange['end'] #dictionary method!             
     81                self.datasetTemporalData = self.isoDataModel.boundingDatesRange # set whole list of dictionaries for this as may be multiple boxes  
     82         
     83        else: 
     84                self.datasetStartNom = 'null' 
     85                self.datasetEndNom = 'null' 
     86                self.datasetTemporalData = 'null' 
    7887         
    7988        #self.datasetEndNom = datasetEndDateNom 
    80         self.datasetEndNom = self.isoDataModel.boundingDatesRange['end'] #dictionary method!     
    81          
    82         self.datasetTemporalData = self.isoDataModel.boundingDatesRange # set whole list of dictionaries for this as may be multiple boxes  
    8389         
    8490        self.datasetSpatialData = self.isoDataModel.boundingBoxCoordinates # set whole list of dictionaries for this as may be multiple boxes 
     
    145151        @return: corrected string  
    146152        ''' 
    147         return re.sub(r'\'', '\\\'', inputString) 
     153         
     154        str = re.sub(r'\'', '\\\'', inputString)                        
     155         
     156        return str 
    148157 
    149158 
     
    156165        ''' 
    157166        str = re.sub(r'%20', ' ', inputString) 
    158         return  
     167        return 
     168        
     169     
     170    def characterEncoding(self,inputString):        
     171                ''' 
     172                Method to use with strings pulled from original xml - try and do a string conversion, catch any unicode errors,  
     173                report it and return a properly encoded string if so 
     174                ''' 
     175                 
     176                convertMsg = '' 
     177                 
     178                try: 
     179                        thisString = str(inputString) 
     180                         
     181                except Exception, error: 
     182                         
     183                        if type(error).__name__ == 'UnicodeEncodeError': 
     184                                 
     185                                #get the position of the dodgy characters & message 
     186                                convertMsg = 'Error with character encoding in this field (%s): %s'%(type(error).__name__,error) 
     187                                logging.warn(convertMsg) 
     188                                 
     189                                #now we've caught this (need to know for future reference rather than do a blanket conversion 
     190                                logging.warn("Converting bad characters to unicode..") 
     191                                 
     192                                thisString = ndgUtilities.encodeIntoHTMLNumericalCodes(inputString) 
     193                                 
     194                                #Need to escape these now 
     195                                thisString = re.sub(r'\\u', '\\\\\u', thisString) 
     196                                 
     197                                 
     198                         
     199                return thisString,convertMsg 
    159200     
    160201     
     
    227268                self._allDocs[self._xqueryDocTypes[docType]] = self.escapeSpecialCharacters(self.getDocumentFormat(docType)) 
    228269                 
     270         
    229271        #remember, if a non ISO input format we need to add the stubISO intermediate format too. 
    230272        #(if original format was ISO, this is covered by the self.originalXMLdoc overrider in the insertMetadata method in PostgresDAO.) 
     
    238280                 
    239281                #must also make sure we use the original dif and use that in here too.. 
    240                 self._allDocs[self.docType] = self.difXML 
     282                self._allDocs[self.docType] = self.escapeSpecialCharacters(self.difXML) 
    241283                 
    242284        else: 
     
    247289                self._allDocs[self.docType] = self.originalFormat 
    248290                 
    249          
     291        
    250292        return self._allDocs 
    251293         
     
    333375         
    334376        logging.info("Parsing Temporal information from original ISO object") 
     377         
    335378                 
    336379        TimeRange = [] 
    337380                                         
    338         if len(timeData) == 0: 
     381        if len(timeData) == 0 or timeData == 'null': 
    339382                        logging.info("No temporal coverage elements found - assuming no temporal data available") 
    340                  
    341         else: 
    342                  
     383                        TimeRange.append({'start':'null','end':'null'}) 
     384                        return TimeRange 
     385        else:            
    343386                         
    344387                start = timeData['start'] 
  • TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch/Utilities.py

    r7186 r7725  
    306306                os.putenv ('PATH', ':/usr/java/jdk1.5.0_03/bin:/usr/java/jdk1.5.0_03:/usr/java/jdk1.5.0_03/lib/tools.jar:/usr/local/WSClients/OAIBatch:/usr/local/exist-client/bin:/bin:/usr/bin:.') 
    307307                xqCommand = "java -cp %s net.sf.saxon.Query %s !omit-xml-declaration=yes" %(self._saxonJarFile, xqFile) 
    308                                  
     308                 
    309309                logging.debug("Running saxon command: " + xqCommand) 
    310310                pipe = os.popen(xqCommand + " 2>&1") 
  • TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch/abstractdocumentingester.py

    r7391 r7725  
    153153                 
    154154                self.recordAttemptToIngestDiscoveryID = "" 
     155                self.ingestWarningMessage = "" 
    155156                 
    156157                self.ingestProblemMessage = "" 
     
    161162                 
    162163                try: 
    163                                                                                                                          
     164                                                                                                                                         
    164165                        self.isoDataModel = ExtractISO(filename,self._isoClass[self._datacentre_format]) 
    165166                         
     
    200201                        #if record is valid (vital elements checked in ExtractISO - validDoc is True if everything ok.. 
    201202                         
    202                         #record whats bout to be ingested - if a problem this, error should already have been kicked out                                         
    203                         self.recordAttemptToIngestDiscoveryID = self.isoDataModel.datasetID[0][0] 
     203                        #record whats bout to be ingested - if a problem this, error should already have been kicked out 
     204                        mappingIndex = self.isoDataModel.findTheListData(self.isoDataModel.datasetID)                                    
     205                        self.recordAttemptToIngestDiscoveryID = self.isoDataModel.datasetID[mappingIndex][0] 
     206                         
    204207                         
    205208                        if self.isoDataModel.validDoc is True:                   
     
    212215                                 
    213216                                # Now create the data access object to interface to the DB                       
    214                                 dao = PostgresDAO(record, self.isoDataModel ,self.discovery_dir , pgClient = self.pgc ) 
     217                                dao = PostgresDAO(record, self.isoDataModel ,self.discovery_dir , pgClient = self.pgc, dpwsID = self._DPWS_ID ) 
    215218                         
    216219                                # Finally, write the new record 
    217                                 # 0 if failed, 1 if update, 2 if create 
    218                                 returnCode = dao.createOrUpdateRecord()  
    219                                                  
     220                                # 0 if failed, 1 if update, 2 if create                          
     221                                returnCode = dao.createOrUpdateRecord() 
     222                                                                 
     223                                if dao.processingWarning != '': 
     224                                        self.ingestWarningMessage = dao.processingWarning 
     225                                                                                 
    220226                                if returnCode == 2: 
    221227                                        self._no_files_ingested += 1 
     
    441447                        elif words[0] == 'feed': 
    442448                                self._IngestViaFeed = True 
     449                        elif words[0] == 'dpws_id': 
     450                                self._DPWS_ID = words[1] 
    443451                         
    444452                datacentre_config_file.close() 
     
    467475                 
    468476                logging.info("datacentre namespace: " + self._datacentre_namespace) 
     477                 
     478                if self._DPWS_ID == "": 
     479                        sys.exit("No DPWS ID entered for this provider!") 
    469480                 
    470481                if self._NDG_dataProvider: 
     
    491502                self.difXML = None 
    492503                 
     504                #create dictionary for a mapping between original files and converted discovery files 
     505                self.originalsDiscoveryFilesMap = {} 
     506                 
    493507                logging.info(self.lineSeparator) 
    494508                logging.info("Renaming files:") 
     
    501515                        sqlStatusCmd = "select update_ingest_status (%s, 'run_ingest');" %self.ingestProcessID 
    502516                        self.pgc_IngestLog.runSQLCommand(sqlStatusCmd) 
     517                         
     518                        sqlStatusCmd = "select update_ingest_info (%s, ' (preprocessing...)');" %(self.ingestProcessID) 
     519                        self.pgc_IngestLog.runSQLCommand(sqlStatusCmd) 
    503520                 
    504521                for filename in os.listdir(originals_dir): 
     
    509526                         
    510527                        original_filename = originals_dir + filename 
     528                         
     529                        #get the name of the file to be used in the xquery 
     530                        metadataFilename = filename.replace('.xml', '') 
     531                                 
    511532                         
    512533                        #if importing old dif format need to do a few extra things: 1. deal with urls to be redirected.  2. Convert to stub ISO so can continue with ISO ingest! 
     
    525546                                repositoryName = self._datacentre_namespace 
    526547                                 
    527                                 #get the name of the file to be used in the xquery 
    528                                 metadataFilename = filename.replace('.xml', '') 
    529548                                                                 
    530549                                #where is the file to be ingested located? 
     
    579598                                         
    580599                                                else: 
    581                                                         ident = isoDataModel.datasetID[0][0] 
     600                                                        mappingIndex = isoDataModel.findTheListData(isoDataModel.datasetID) 
     601                                                        ident = isoDataModel.datasetID[mappingIndex][0] 
    582602                                         
    583603                                                        ident = ident.replace(":", "-") 
     
    617637                                        badXMLfiles += 1 
    618638                                        self.badXMLfileList[new_filename_short]=filename 
     639                                         
     640                                self.originalsDiscoveryFilesMap[new_filename_short] = filename 
    619641                                 
    620642                         
     
    640662                                 
    641663                                                else: 
    642                                          
    643                                                         ident = isoDataModel.datasetID[0][0] 
    644                                  
     664                                                        mappingIndex = isoDataModel.findTheListData(isoDataModel.datasetID)      
     665                                                        ident = isoDataModel.datasetID[mappingIndex][0] 
     666                                                         
    645667                                                        ident = ident.replace(":", "-") 
    646668                                                        ident = ident.replace("/", "-") 
     
    683705                                        badXMLfiles += 1 
    684706                                        self.badXMLfileList[new_filename_short]=filename 
     707                                 
     708                         
     709                                self.originalsDiscoveryFilesMap[new_filename_short] = filename 
    685710                         
    686711                logging.info("File renaming and converting completed") 
     
    773798                 
    774799                ingestProbMsg = "" 
     800                ingestWarnMsg = "" 
    775801                                 
    776802                #generate a list of files ALREADY in database so can compare with what has been ingested 
     
    791817                self.deletedFailList = [] 
    792818                self.problemMessageList = {}     
     819                self.warnMessageList = {} 
    793820                 
    794821                counter = 1 
     822                warningCounter = 0 
    795823                                 
    796824                for filename in filenames: 
     
    799827                         
    800828                        #if process id has been supplied, then update the logging db with a "start_ingest" 
    801                         #sqlStatusCmd = "select update_ingest_status (%s, 'run_ingest %s/%s');" %(self.ingestProcessID,counter,numfilesproc) 
    802                         #sqlStatusCmd = "select update_ingest_status (%s, 'run_ingest');" %self.ingestProcessID 
    803                         #self.pgc_IngestLog.runSQLCommand(sqlStatusCmd) 
     829                        if self.ingestProcessID is not None and self.procID is None: 
     830                                sqlStatusCmd = "select update_ingest_info (%s, ' (ingesting %s of %s)');" %(self.ingestProcessID,counter,numfilesproc)                   
     831                                self.pgc_IngestLog.runSQLCommand(sqlStatusCmd) 
     832                         
    804833                         
    805834                        if os.path.isfile(fullPath): 
     
    809838                                #record all problem messages 
    810839                                #ingestProbMsg = ingestProbMsg + self.ingestProblemMessage + "\n" 
    811                                  
    812840                                if self.ingestProblemMessage != '': 
    813                                         ingestProbMsg = ingestProbMsg + self.ingestProblemMessage 
    814                                          
    815                                         self.problemMessageList[filename] = self.ingestProblemMessage 
     841                                        ingestProbMsg = ingestProbMsg + self.ingestProblemMessage                                        
     842                                        self.problemMessageList[self.originalsDiscoveryFilesMap[filename]] = self.ingestProblemMessage 
     843                                         
     844                                if self.ingestWarningMessage != '': 
     845                                        warningCounter += 1 
     846                                        ingestWarnMsg = ingestWarnMsg + self.ingestWarningMessage 
     847                                        self.warnMessageList[filename] = self.ingestWarningMessage 
    816848                                         
    817849                                #remove this filename from the list of files for this DC already in list (whats left over is to be deleted)  
     
    820852                                                filesPresentList.remove(thisIngestedID) 
    821853                         
     854                         
    822855                        counter += 1     
    823                                  
     856                 
    824857                #test loop through remaining items in filePresentList - in order to synchronise with ingest directory - these 
    825858                #will need to be removed. 
     
    846879                #Update log file details op on ingest to s atring which is THEN wrtten to a file, so as can return and email for info editor 
    847880                self.thisIngestEndDate = str(datetime.datetime.now()) 
     881                 
     882                messageSeparator = "\n\n********************************************************************************" 
    848883                 
    849884                message = "Ingest report for data centre: " + datacentre + "\n" 
     
    855890                message = message + "INGESTED_Created " + str(self._no_files_ingested)  + "\n" 
    856891                message = message + "INGESTED_Updated " + str(self._no_files_changed)  + "\n" 
    857                 message = message + "DELETED " + str(self._no_files_deleted)  + "\n"             
    858                 message = message + "PROBLEM_FILES " + str(self._no_problem_files)  + "\n" 
    859                                                  
     892                message = message + "DELETED " + str(self._no_files_deleted)  + "\n" 
     893                 
     894                if warningCounter > 0: 
     895                        message = message + messageSeparator 
     896                        message = message + "\nINGEST WARNINGS:  " + str(warningCounter) + "\n" 
     897                         
     898                        message = message +  "\nBelow are the files that had ingest warnings...\n\n" 
     899                         
     900                        for warnFile in self.warnMessageList.keys(): 
     901                                message = message + "\nWARNING_FILE " + self.originalsDiscoveryFilesMap[warnFile] + "    " + self.warnMessageList[warnFile] + "\n" 
     902                         
     903                 
     904                if self._no_problem_files > 0:  
     905                        message = message + messageSeparator 
     906                        message = message + "\nPROBLEM_FILES: " + str(self._no_problem_files)  + "\n" 
     907                         
     908                 
    860909                if len(self.updateFailList) > 0: 
    861910                        message = message +  "\nBelow are comments recorded on problem files...\n\n" 
    862                  
     911                                         
    863912                        for badFile in self.updateFailList: 
    864                                 #recOpFile.write("PROBLEM_FILE " + badFile + "\n")       
    865                                 message = message +"\nPROBLEM_FILE " + badFile + "\n" 
     913                                #recOpFile.write("PROBLEM_FILE " + badFile + "\n") 
     914                                 
     915                                #NOTE: there may not be a problem message for every file that failed to ingest.. 
     916                                if badFile in self.problemMessageList.keys(): 
     917                                        message = message +"\nPROBLEM_FILE " + badFile + "\n" 
     918                                        message = message + self.problemMessageList[badFile] + "\n" 
     919                                 
    866920                 
    867921                if len(self.badXMLfileList.keys()) > 0: 
     922                        message = message + messageSeparator 
    868923                        message = message +  "\nBelow are the files that could not be parsed (i.e. bad XML?)...\n\n" 
    869924                        for badXmlFile in self.badXMLfileList.values(): 
    870                                 message = message + "BAD_XML_FILE " + badXmlFile +"\n" 
     925                                message = message + "BAD_XML_FILE: " + badXmlFile +"\n" 
    871926                 
    872927                                                 
     
    891946                                                sqlProbFileCmd = "select add_problem_file(%s,'%s','%s');"%(self.ingestProcessID,badFile,'Could not catch precise error for this file!!') 
    892947                                 
    893                                                 #update ingestLogging                    
     948                                                #update ingestLogging            
    894949                                                self.pgc_IngestLog.runSQLCommand(sqlProbFileCmd) 
    895950                                 
     
    908963                         
    909964                #update with content from the problem messages recorded 
    910                 message = message + ingestProbMsg + "\n"                 
     965                #message = message + ingestProbMsg + "\n"                
    911966                          
    912967                recOpFile.write(message) 
  • TI01-discovery-Ingest/trunk/v4.3.0/ingestAutomation-upgrade/OAIBatch/difConvertedto_ISO19139.py

    r7456 r7725  
    5151                dataCentreName = (self.dataCentreName.__name__,{1:{ 
    5252                                                                                                        'baseXpath':'gmd:contact/gmd:CI_ResponsibleParty', 
    53                                                                                                         'elValXpath':'organisationName/gco:CharacterString', 
    54                                                                                                         'depValXpath':'role/gmd:CI_RoleCode', 
    55                                                                                                         'depVal':'disributor'}}) 
     53                                                                                                        'elValXpath':'gmd:organisationName/gco:CharacterString', 
     54                                                                                                        'depValXpath':'gmd:role/gmd:CI_RoleCode', 
     55                                                                                                        'depVal':'pointOfContact'}}, 
     56                                                                                                        {2:{ 
     57                                                                                                        'baseXpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:pointOfContact/gmd:CI_ResponsibleParty', 
     58                                                                                                        'elValXpath':'gmd:organisationName/gco:CharacterString', 
     59                                                                                                        'depValXpath':'gmd:role/gmd:CI_RoleCode', 
     60                                                                                                        'depVal':'pointOfContact'}}) 
    5661                 
    5762                return dataCentreName 
     
    130135                ''' 
    131136                 
    132                 authors = (self.authors.__name__,{1:{'xpath':'gmd:contact/gmd:CI_ResponsibleParty/gmd:individualName/gco:CharacterString'}}) 
     137                authors = (self.authors.__name__,{1:{'xpath':'gmd:contact/gmd:CI_ResponsibleParty/gmd:individualName/gco:CharacterString'}},{2:{'xpath':'gmd:contact/gmd:CI_ResponsibleParty/gmd:organisationName/gco:CharacterString'}},{3:{'xpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:pointOfContact/gmd:CI_ResponsibleParty/gmd:organisationName/gco:CharacterString'}}) 
    133138                 
    134139                return authors 
     
    140145                ''' 
    141146                #Note that in StubISO same element structure is used for related_urls! 
    142                 parameters = (self.parameters.__name__,{1:{                                                                      
     147                 
     148                '''parameters = (self.parameters.__name__,{1:{                                                                   
    143149                'baseXpath':'distributionInfo/gmd:MD_Distribution/transferOptions', 
    144150                'elValXpath':'gmd:MD_DigitalTransferOptions/gmd:onLine/gmd:CI_OnlineResource/description/gco:CharacterString', 
    145151                'depValXpath':'gmd:MD_DigitalTransferOptions/gmd:onLine/gmd:CI_OnlineResource/function/gmd:CI_onLineFunctionCode', 
    146                 'depVal':'DIF:PARAMETERS'}}) 
     152                'depVal':'DIF:PARAMETERS'}})''' 
     153                 
     154                parameters = (self.parameters.__name__, {1:{'xpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:descriptiveKeywords/gmd:MD_TopicCategoryCode'}}) 
    147155                 
    148156                return parameters 
     
    154162                See notes in metadataDates for tuple format 
    155163                ''' 
    156                 keywords = (self.keywords.__name__,{1:{'xpath':'gmd:identificationInfo/gmd:descriptiveKeywords/gmd:MD_Keywords/gmd:keyword/gmx:anchor'}}, 
    157                                                                                 {2:{'xpath':'gmd:identificationInfo/gmd:topicCategory/gmd:MD_TopicCategoryCode'}} 
    158                                                  
     164                keywords = (self.keywords.__name__,{1:{'xpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:descriptiveKeywords/gmd:MD_Keywords/gmd:keyword/gco:CharacterString'}}, 
     165                                                                                        {2:{'xpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:descriptiveKeywords/gmd:MD_Keywords/gmd:keyword/gmx:Anchor'}} 
     166                                                                                 
    159167                                ) 
    160168                 
     
    213221                ''' 
    214222                 
    215                 creationDate = (self.metadataCreationDate.__name__,{1:{'baseXpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:citation/gmd:CI_Citation/date', 
    216                                                                                                                         'elValXpath':'gmd:CI_Date/date/gco:DateTime', 
    217                                                                                                                         'depValXpath':'gmd:CI_Date/dateType/gmd:CI_DateTypeCode', 
     223                creationDate = (self.metadataCreationDate.__name__,{1:{'baseXpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:citation/gmd:CI_Citation/gmd:date', 
     224                                                                                                                        'elValXpath':'gmd:CI_Date/gmd:date/gco:Date', 
     225                                                                                                                        'depValXpath':'gmd:CI_Date/gmd:dateType/gmd:CI_DateTypeCode', 
    218226                                                                                                                        'depVal':'creation'}}) 
    219                  
    220                  
     227                                 
    221228                return creationDate 
    222229         
     230         
    223231        ''' 
    224232        Return xpaths to revisionDate 
    225233        ''' 
     234        def metadataPublicationDate(self): 
     235                 
     236                publicationDate = (self.metadataPublicationDate.__name__,{1:{'baseXpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:citation/gmd:CI_Citation/gmd:date', 
     237                                                                                                                        'elValXpath':'gmd:CI_Date/gmd:date/gco:Date', 
     238                                                                                                                        'depValXpath':'gmd:CI_Date/gmd:dateType/gmd:CI_DateTypeCode', 
     239                                                                                                                        'depVal':'publication'}}) 
     240                 
     241                return publicationDate 
     242         
     243         
     244         
     245         
     246        ''' 
     247        Return xpaths to revisionDate 
     248        ''' 
    226249        def metadataRevisionDate(self): 
    227250                 
    228                 revisionDate = (self.metadataRevisionDate.__name__,{1:{'baseXpath':'gmd:identificationInfo/gmd:MD_DataIdentification/gmd:citation/gmd:CI_Citation/date', 
    229                                                                                                                         'elValXpath':'gmd:CI_Date/date/gco:DateTime', 
    230                                                                                                                         'depValXpath':'gmd:CI_Date/dateType/gmd:CI_DateTypeCode', 
    231                                                                                                                         'depVal':'revision'}}) 
     251                revisionDate = (self.metadataRevisionDate.__name__,{1:{'xpath':'gmd:dateStamp/gco:DateTime'}}) 
    232252                 
    233253                return revisionDate 
Note: See TracChangeset for help on using the changeset viewer.