Changeset 4163


Ignore:
Timestamp:
Apr 10, 2017, 2:50:04 PM (3 years ago)
Author:
Juanma
Message:

WIP on core

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lliurex-abies2pmb/trunk/fuentes/lliurex-abies2pmb-core.install/abies2pmb.py

    r4113 r4163  
    11#!/usr/bin/python3
    22import os
    3 import time
     3import datetime
    44# -*- coding: utf-8 -*-
    55class abiesToPmb():
     
    88                #Dict with relations between pmb and abies
    99                self.pmb_abies={}
    10                 self.pmb_abies["docs_location"]=("Ubicaciones")
    11                 self.pmb_abies["empr_categ"]=("TiposLector")
     10
     11                self.pmb_abies["empr_categ"]=["TiposLector"]
     12                self.pmb_abies["docs_location"]=["Ubicaciones"]
    1213                self.pmb_abies["authors"]=["Autores"]
     14                self.pmb_abies["exemplaires"]=["Ejemplares"]
     15                self.pmb_abies["notices"]=["Fondos","Fondos-CDUs"]
     16                self.pmb_abies["collections"]=["Series"]
     17                self.pmb_abies["notices_langues"]=["Fondos-Idiomas"]
    1318                self.pmb_abies["publishers"]=["Editoriales"]
    1419                self.pmb_abies["groupe"]=["Cursos"]
    15                 self.pmb_abies["exemplaires"]=["Ejemplares"]
     20                self.pmb_abies["indexint"]=["CDUs"]
     21                self.pmb_abies["notices_tmp"]=["Fondos_all"]
     22
    1623                #Dict with abies source fields for pmb
    1724                self.pmb_tables={}
     
    2128                self.pmb_tables["publishers"]=[0,1,'','','','','','','','']
    2229                self.pmb_tables["groupe"]=[0,1,'','','','']
    23                 self.pmb_tables["exemplaires"]=[0,4,1,'','',13,'','',6,'','','','','','','','',8,'','','','','','','','','']
    24                 #Dict with temp results
    25                 self.pmb_result={}
    26 
    27                 self.virtual_tables["CDU"]=[0,1]
    28 
     30                self.pmb_tables["exemplaires"]=[0,4,1,'','',13,'','',6,'','','','','','','','',9,'','','','','','','','','']
     31                self.pmb_tables["collections"]=[0,1,'','','','','','']
     32                self.pmb_tables["indexint"]=[0,1,'','','']
     33                self.pmb_tables["notices_tmp"]=[0,1,2]
     34                self.pmb_tables["notices"]=[0,1,14,15,16,13,'','',19,'',24,'',20,17,25,11,21,22,'',23,'','','','','',26,'','','','','','','','','','','','','','',6,'','','','','','','','','','','','','','']
     35
     36                #dict with needed virtual tables
     37                self.virtual_tables={}
     38                self.virtual_tables["CDUs"]={}
     39                self.virtual_tables["CDUs"].update({'index 0':''})
     40                self.virtual_tables["CDUs"].update({'index 1':'get Fondos_CDUs.1'})
     41                self.virtual_tables['Series']={}
     42                self.virtual_tables['Series'].update({'index 0':''})
     43                self.virtual_tables['Series'].update({'index 1':'get Fondos.24'})
     44                self.virtual_tables['Fondos_all']={'index 0':'get Fondos.0'}
     45                self.virtual_tables['Fondos_all'].update({'index 1':''})
     46                self.virtual_tables['Fondos_all'].update({'index 2':''})
     47
     48                #Dict whith field transformations
     49                self.formatFields={}
     50                self.formatFields['TiposLector']={'index 0':'add index 0 7'}
     51                self.formatFields['Autores']={'index 1':'value 100=70,value 110=71,value 120=72,value 700=70'}
     52                self.formatFields['Ejemplares']={'index 13':'concat 13,14,15'}
     53                self.formatFields['Ejemplares'].update({'index 9':'date %m/%d/%y %H:%M:%S %Y-%m-%d %H:%M:%S'})
     54                self.formatFields['CDUs']={'index 0':'inc 1 1000'}
     55                self.formatFields['Series']={'index 0':'inc 1 1000'}
     56#               self.formatFields['Fondos_all']={'index 2':'from CDUs.0 on 0=1'}
     57                self.formatFields['Fondos']={'index 1':'value 1="a",value 2="g",value 3="m",value4="j",value 5="k",value 6="a",value 7="l"'}
     58                self.formatFields['Fondos'].update({'index 13':'from Autores.2 on 13=0'})
     59                self.formatFields['Fondos'].update({'index 24':'from Series.0 on 24=0'})
     60                self.formatFields['Fondos'].update({'index 26':'from Fondos_all.2 on 0=1'})
     61
     62                #Dict whith special columns
     63                self.formatTables={}
     64                self.formatTables['CDUs']={'index 1':'uniq'}
     65                self.formatTables['Series']={'index 1':'uniq'}
     66                self.formatTables['Fondos_all']={'index 1':'from Fondos_CDUs.1 on 0=0'}
     67                self.formatFields['Fondos_all']={'index 2':'from CDUs.0 on 0=1'}
    2968#DEPRECATED
    3069                #Dict with needed fields from abies
     
    3776                self.abies_fields["Ejemplares"]=[0,4,2,"13+14+15",6,8]
    3877                self.abies_fields["Fondos_CDUs"]=[0,"1>CDUs.0"]
     78                self.abies_fields["Series"]=[0,1]
    3979#DEPRECATED
    4080
     81                #Dict with temp results
     82                self.pmb_result={}
     83
    4184                #Array with process order
    42                 self.executionOrder=['Ubicaciones','TiposLector','Autores','Editoriales','Cursos','Ejemplares','CDU']
     85                self.executionOrder=['Ubicaciones','TiposLector','Autores','Editoriales','Cursos','Ejemplares','Series','CDUs','Fondos_all','Fondos']
     86#               self.executionOrder=['Series']
    4387                #Tmp variables
    4488                self.workDir='/tmp/.abiesToPmb/'
    4589                self.tmpTableDict={}
    4690                self.tableValuesDict={}
    47                 self.formatFields={}
    48                 self.formatFields['TiposLector']={'index 0':'add index 0 7'}
    49                 self.formatFields['Autores']={'index 1':'value 100=70,value 110=71,value 120=72,value 700=70'}
    50                 self.formatFields['Ejemplares']={'index 13':'concat 13,14,15'}
    51                 self.formatFields['Ejemplares']={'index 8':'date %m/%d/%y %H:%M:%S %Y-%m-%d %H:%M:%S'}
    52                 self.formatFields['CDU']={'index 0':'1000+inc'}
    53                 self.formatFields['CDU']={'index 1':'Fondos-CDU.1'}
     91                self.tmpInc=0
     92
    5493
    5594        def _debug(self,msg):
     
    65104        def beginMigration(self):
    66105                for abiesTable in self.executionOrder:
     106                        self.tmpInc=0
    67107                        self._debug("Processing "+abiesTable)
    68108                        self._loadTable(abiesTable)
    69                         transformDict=self._checkTransformField(abiesTable)
    70109                        pmbTable=self._getTableEquivalence(abiesTable)
    71                         self._generateSql(pmbTable,self.tableValuesDict[abiesTable],transformDict)
     110                        self._generateSql(pmbTable,abiesTable)
    72111                print ("Files generated for tables "+str(self.executionOrder))
    73112        #def beginMigration
     
    78117        #Output: Array of sql sentences
    79118        ###
    80         def _generateSql(self,destTable,origData,transformDict):
     119        def _generateSql(self,destTable,abiesTable):
     120                transformDict=self._checkTransformField(abiesTable)
     121                origData=self.tableValuesDict[abiesTable]
    81122                fileName=destTable+".sql"
    82123                f=open (fileName,'w')
     
    84125                        strInsertValues=''
    85126                        for index in self.pmb_tables[destTable]:
    86                                         #                               self._debug("Line: "+str(index))
    87127                                if index!='':
    88128                                        if transformDict:
     
    97137                                                int(tmp)
    98138                                        except:
     139                                                tmp=tmp.lstrip(' ')
     140                                                tmp=tmp.rstrip(' ')
    99141                                                tmp='"'+tmp+'"'
    100142                                                pass
     
    107149        #def fileParser
    108150       
    109 
    110         ###
    111         #Creates the virtualTables
    112         #Input: Table to create
    113         #Input: source fields array
    114         ###
    115         def createVirtualTable(self,tableName='',fieldsList=[]):
    116                 pass
    117         #def createVirtualTable
    118 
    119151        #Gets the value from a file
    120152        #Input: Tablename
     
    141173                                        array=line.split('|||')
    142174                                        data.append(array)
    143                                 self.tableValuesDict[tableName]=data
    144175                        except Exception as e:
    145176                                self._error(e)
    146177                else: #Check in virtual dict
    147                         pass
     178                        if tableName in self.virtual_tables.keys():
     179                                data=self._loadVirtualTable(tableName)
     180                        else:
     181                                self._error("Table "+tableName+" not found")
     182
     183                self.tableValuesDict[tableName]=data
     184                if tableName in self.formatTables.keys():
     185                                self.tableValuesDict[tableName]=self._checkTransformTables(tableName)
     186
     187        def _loadVirtualTable(self,tableName):
     188                self._debug("Loading virtual table "+tableName)
     189                data=[]
     190                dataDict={}
     191                if tableName in self.virtual_tables.keys():
     192                        proceed=False
     193                        for key,line in self.virtual_tables[tableName].items():
     194#                               print (s)ourceData)
     195#                               for key,line in sourceData.items():
     196                                        if line.startswith('get'):
     197                                                proceed=True
     198                                                sourceIndex=key.split(' ')[1]
     199                                                getFrom=line.split(' ')[1]
     200                                                sourceIndex=getFrom.split('.')[1]
     201                                                sourceTable=getFrom.split('.')[0]
     202                                                dataDict[key]=self._funcGetValueFromTable(sourceTable,sourceIndex)
     203                        if proceed:
     204                                #Data is charged on the dataDict, time to populate data array
     205                                maxLen=0
     206                                for key in dataDict.keys():
     207                                        columnLen=len(dataDict[key])
     208                                        if columnLen>maxLen:
     209                                                maxLen=columnLen
     210                                index=0
     211                                while index<maxLen:
     212                                        dataLine=[]
     213                                        for key in self.virtual_tables[tableName].keys():
     214                                                arrayIndex=int(key.split(' ')[-1])
     215                                                if key in dataDict.keys():
     216                                                        dataLine.insert(arrayIndex,dataDict[key][index])
     217                                                else:
     218                                                        dataLine.insert(arrayIndex,'')
     219                                        data.append(dataLine)
     220                                        index=index+1
     221                else:
     222                        self._error("No source for virtual table "+tableName)
     223                return(data)
    148224
    149225        def _getTableEquivalence(self,tableName):
     
    159235                if abiesTable in self.formatFields.keys():
    160236                        transform=self.formatFields[abiesTable]
    161 #                       self._debug("Transforming fields "+str(transform)+" in "+abiesTable)
     237                        self._debug("Transforming fields "+str(transform)+" in "+abiesTable)
    162238                        for key,line in transform.items():
    163239                                index=int(key.split(' ')[-1])
    164                                 print(line)
    165240                                if line.startswith('add'):
    166241                                        transformDict[index]=self._transformAdd(line,index)
     
    171246                                elif line.startswith('date'):
    172247                                        transformDict[index]=self._transformDate(line,index)
    173 
    174 #               self._debug("TransformDict: "+str(transformDict))
     248                                elif line.startswith('inc'):
     249                                        transformDict[index]=self._transformInc(line,index)
     250                                elif line.startswith('get'):
     251                                        transformDict[index]=self._transformGet(line,index)
     252                                elif line.startswith('from'):
     253                                        transformDict[index]=self._transformQuery(line,index,abiesTable)
     254
     255                self._debug("TransformDict: "+str(transformDict))
    175256                return transformDict
    176257
    177                 def _transformAdd(self,line,index):
    178                                 sourceIndex=line.split(' ')[1]
    179                                 increment=line.split(' ')[-1]
    180                                 returnValue='int(line['+sourceIndex+'])+'+increment
    181                                 return(returnValue)
    182 
    183                 def _transformValue(self,line,index):
    184                                 values=line.split(',')
    185                                 tmpStr=''
    186                                 for value in values:
    187                                         relation=value.split('=')
    188                                         sourceValue=relation[0].split(' ')[-1]
    189                                         destValue=relation[-1]
    190                                         tmpStr=tmpStr+str(destValue)+' if line['+str(index)+']=="'+str(sourceValue)+'" else '
    191                                 returnValue='('+tmpStr+ '"'+str(destValue)+'")'
    192                                 return(returnValue)
    193 
    194                 def _transformConcat(self,line,index):
    195                                 concat=line.split(' ')[-1]
    196                                 concatArray=concat.split(',')
    197                                 tmpStr=''
    198                                 for concatField in concatArray:
    199                                         tmpStr=tmpStr+'line['+str(concatField)+']+'
    200                                 returnValue=tmpStr[:-1]
    201                                 return(returnValue)
    202 
    203                 def _transformDate(self,line,index):
    204 
    205                                 dates=line.split(' ')
    206                                 sourceFormat=dates[1]
    207                                 destFormat=dates[-1]
    208                                 returnValue='self._funcDateTransform(line['+str(index)+'],'+sourceFormat+','+destFormat
    209                                 return(returnValue)
    210 
    211                 def _funcDateTransform(self,date,origFormat,destFormat):
    212                                
     258        def _transformAdd(self,line,index):
     259                sourceIndex=line.split(' ')[1]
     260                increment=line.split(' ')[-1]
     261                returnValue='int(line['+sourceIndex+'])+'+increment
     262                return(returnValue)
     263
     264        def _transformValue(self,line,index):
     265                values=line.split(',')
     266                tmpStr=''
     267                for value in values:
     268                        relation=value.split('=')
     269                        sourceValue=relation[0].split(' ')[-1]
     270                        destValue=relation[-1]
     271                        tmpStr=tmpStr+str(destValue)+' if line['+str(index)+']=="'+str(sourceValue)+'" else '
     272                try:
     273                        int(destValue)
     274                        returnValue='('+tmpStr+ '"'+str(destValue)+'")'
     275                except:
     276                        returnValue='('+tmpStr+ ''+str(destValue)+')'
     277                return(returnValue)
     278
     279        def _transformConcat(self,line,index):
     280                concat=line.split(' ')[-1]
     281                concatArray=concat.split(',')
     282                tmpStr=''
     283                for concatField in concatArray:
     284                        tmpStr=tmpStr+'line['+str(concatField)+']+'
     285                returnValue=tmpStr[:-1]
     286                return(returnValue)
     287
     288        def _transformDate(self,line,index):
     289                dates=line.split(' ')
     290                sourceFormat=dates[1]+' '+dates[2]
     291                destFormat=dates[3]+' '+dates[4]
     292                returnValue='self._funcDateTransform(line['+str(index)+'],"'+sourceFormat+'","'+destFormat+'")'
     293                return(returnValue)
     294
     295        def _funcDateTransform(self,date,origFormat,destFormat):
     296                date=date.replace('"','')
     297                destFormat=destFormat.replace('"','')
     298                returnValue=(datetime.datetime.strptime(date, origFormat).strftime(destFormat))
     299                return(returnValue)
     300               
     301        def _transformInc(self,line,index):
     302                increment=line.split(' ')
     303                inc=increment[1]
     304                base=0
     305                if len(increment)==3:
     306                        base=int(increment[2])
     307                if self.tmpInc<base:
     308                        self.tmpInc=base
     309                returnValue='self._funcIncrementField('+inc+')'
     310                return(returnValue)
     311
     312        def _funcIncrementField(self,inc):
     313                self.tmpInc=self.tmpInc+int(inc)
     314                returnValue=self.tmpInc
     315                return(returnValue)
     316
     317        def _transformGet(self,line,index):
     318                getFrom=line.split(' ')[-1]
     319                getFromTable=getFrom.split('.')[0]
     320                getFromIndex=getFrom.split('.')[-1]
     321                returnValue='self._funcGetValueFromTable('+getFromTable+','+getFromIndex+')'
     322                return(returnValue)
     323
     324        def _funcGetValueFromTable(self,table,index):
     325                fileName=table+'.csv'
     326                data=[]
     327                index=int(index)
     328                if os.path.exists(fileName):
     329                        try:
     330                                f=open(fileName,'r')
     331                                lines=f.readlines()
     332                                f.close()
     333                                for line in lines:
     334                                        array=line.split('|||')
     335                                        data.append(array[index])
     336                        except Exception as e:
     337                                self._error(e)
     338                else:
     339                        self._error("No source table "+fileName+" available")
     340                return(data)
     341
     342        def _transformQuery(self,line,index,tableName):
     343                self._debug("Join field "+line)
     344                transformDict=[]
     345                arrayLine=line.split(' ')
     346                sourceTableField=arrayLine[1]
     347                joinFromTo=arrayLine[-1]
     348                sourceTable=sourceTableField.split('.')[0]
     349                sourceField=int(sourceTableField.split('.')[1])
     350                joinFrom=joinFromTo.split('=')[0]
     351                joinTo=joinFromTo.split('=')[1]
     352                returnValue='self._funcGetValueFromQuery("'+tableName+'","'+sourceTable+'",line['+str(joinFrom)+'],'+str(joinTo)+','+str(sourceField)+')'
     353                return(returnValue)
     354
     355        def _funcGetValueFromQuery(self,abiesTable,sourceTable,valueFrom,fieldTo,reqFieldIndex):
     356                returnValue=''
     357                valueFrom=valueFrom.strip("\n")
     358                if sourceTable not in self.tableValuesDict:
     359                        self._loadTable(sourceTable)
     360                for row in self.tableValuesDict[sourceTable]:
     361                                #                       print ("Comparing "+str(valueFrom)+" with "+str(row[fieldTo]))
     362                        if valueFrom==str(row[fieldTo]).strip("\n"):
     363                                returnValue=row[reqFieldIndex]
     364                                break
     365                print("Result: "+str(returnValue))
     366                return returnValue
     367
     368
     369        def _checkTransformTables(self,tableName):
     370                transformDict={}
     371                if tableName in self.formatTables.keys():
     372                        transform=self.formatTables[tableName]
     373                        for key,line in transform.items():
     374                                index=int(key.split(' ')[-1])
     375                                if line.startswith('uniq'):
     376                                        transformDict=self._transformTableUniq(tableName,index)
     377                                if line.startswith('from'):
     378                                        transformDict=self._transformTableJoin(tableName,index,line)
     379                return transformDict
     380
     381        def _transformTableUniq(self,tableName,index):
     382                self._debug("Uniq items from index "+str(index))
     383                transformDict=[]
     384                for item in self.tableValuesDict[tableName]:
     385                        if item not in transformDict:
     386                                transformDict.append(item)
     387                return transformDict
     388
     389        def _transformTableJoin(self,tableName,index,line):
     390                self._debug("Join "+line)
     391                transformDict=[]
     392                arrayLine=line.split(' ')
     393                sourceTableField=arrayLine[1]
     394                joinFromTo=arrayLine[-1]
     395                sourceTable=sourceTableField.split('.')[0]
     396                sourceField=int(sourceTableField.split('.')[1])
     397                joinFrom=joinFromTo.split('=')[0]
     398                joinTo=joinFromTo.split('=')[1]
     399                if sourceTable not in self.tableValuesDict:
     400                        self._loadTable(sourceTable)
     401                #Generate a dict with joinTo as index and required field as value
     402                tmpDict={}
     403                tmpIndex=int(joinTo)
     404                for row in self.tableValuesDict[sourceTable]:
     405                        rowIndex=row[tmpIndex]
     406                        rowValue=row[sourceField]
     407                        tmpDict.update({rowIndex:rowValue})
     408
     409                #Walk through origin table and insert values from sourceTableDict
     410                tmpIndex=int(joinFrom)
     411                print("Setting values from "+tableName + " field: "+joinFrom)
     412                for row in self.tableValuesDict[tableName]:
     413                        rowIndex=row[tmpIndex]
     414                        if rowIndex in tmpDict:
     415                                row.insert(tmpIndex,tmpDict[rowIndex])
     416                        else:
     417                                row.insert(tmpIndex,'')
     418                        transformDict.append(row)
     419                return transformDict
    213420
    214421### MAIN PROGRAM ###
Note: See TracChangeset for help on using the changeset viewer.