source: lliurex-abies2pmb/trunk/fuentes/lliurex-abies2pmb.install/usr/share/lliurex-abies2pmb/abies2pmb.py @ 4292

Last change on this file since 4292 was 4292, checked in by Juanma, 2 years ago

Added responsability table

  • Property svn:executable set to *
File size: 20.6 KB
Line 
1#!/usr/bin/python3
2import os
3import datetime
4import subprocess
5import sys
6import tempfile
7# -*- coding: utf-8 -*-
8class abies2Pmb():
9        def __init__(self):
10                self.dbg=0
11               
12                #Dict with relations between pmb and abies
13                self.pmb_abies={}
14                self.pmb_abies["empr_categ"]=["TiposLector"]
15                self.pmb_abies["docs_location"]=["Ubicaciones"]
16                self.pmb_abies["authors"]=["Autores"]
17                self.pmb_abies["exemplaires"]=["Ejemplares"]
18                self.pmb_abies["notices"]=["Fondos"]
19                self.pmb_abies["collections"]=["Series"]
20                self.pmb_abies["notices_langues"]=["Fondos_Idiomas"]
21                self.pmb_abies["publishers"]=["Editoriales"]
22                self.pmb_abies["groupe"]=["Cursos"]
23                self.pmb_abies["indexint"]=["CDUs"]
24                self.pmb_abies["notices_tmp"]=["Fondos_all"]
25                self.pmb_abies["docs_type"]=["TiposFondo"] 
26                self.pmb_abies["docs_statut"]=["TiposEjemplar"] 
27                self.pmb_abies["responsability"]=["Fondos_Autores"] 
28
29                #Dict with forced column data type
30                self.formatPmbColumns={}
31                self.formatPmbColumns['indexint']={1:'string'}
32                self.formatPmbColumns['indexint'].update({3:'string'})
33
34                #Dict with default values to column
35                self.defaultPmbValues={}
36                self.defaultPmbValues['docs_location']={5:'1'}
37                self.defaultPmbValues['indexint']={4:'1'}
38                self.defaultPmbValues['notices']={29:'"m"'}
39                self.defaultPmbValues['notices'].update({38:'1'})
40                self.defaultPmbValues['exemplaires']={6:'28'}
41                self.defaultPmbValues['exemplaires'].update({9:'10'})
42                self.defaultPmbValues['exemplaires'].update({14:'2'})
43                self.defaultPmbValues['exemplaires'].update({23:'1'})
44                self.defaultPmbValues['docs_type']={2:'15'}
45                self.defaultPmbValues['docs_type'].update({3:'15'})
46                self.defaultPmbValues['docs_type'].update({7:'1'})
47                self.defaultPmbValues['docs_statut']={6:'1'}
48                self.defaultPmbValues['docs_statut'].update({7:'1'})
49                self.defaultPmbValues['responsability']={2:'"070"'}
50
51
52                #Blacklist pmb_abies tables.
53                self.blacklist=['notices_tmp']
54
55                #Dict with abies source fields for pmb
56                #Numbers are the indexes of the source data table
57                self.pmb_tables={}
58                self.pmb_tables["docs_location"]=[0,1,'','','','','','','','','','','','','','','','','','','','','','','']
59                self.pmb_tables["empr_categ"]=[0,1,'','','','']
60                self.pmb_tables["authors"]=[0,1,2,'','','','','','','','','','','','']
61                self.pmb_tables["publishers"]=[0,1,'','','','','','','','']
62                self.pmb_tables["groupe"]=[0,1,'','','','']
63                self.pmb_tables["exemplaires"]=[0,4,1,'',3,13,'',2,6,'','','','','','','','',9,'','','','','','','','','']
64                self.pmb_tables["collections"]=[0,1,'','','','','','']
65                self.pmb_tables["indexint"]=[0,1,'',1,'']
66                self.pmb_tables["notices_tmp"]=[0,1,2,3,4,5]
67                self.pmb_tables["notices"]=[0,1,14,15,16,13,'','',19,'',24,'',20,17,25,11,21,22,23,'','','','','','','',26,'','','','','','','','','','','','','',6,'','','','','','','','','','','','','']
68                self.pmb_tables["notices_langues"]=[0,'',1,'']
69                self.pmb_tables["docs_type"]=[0,1,'','','','','','']
70                self.pmb_tables["docs_statut"]=[0,1,'','','','','','','']
71                self.pmb_tables["responsability"]=[1,0,'','','']
72                #dict with needed virtual tables
73                #Only load one column using a 'get', any other column must be charged with formatTables or formatFields
74                self.virtual_tables={}
75                self.virtual_tables["CDUs"]={}
76                self.virtual_tables["CDUs"].update({'index 0':''})
77                self.virtual_tables["CDUs"].update({'index 1':'get Fondos_CDUs.1'})
78                self.virtual_tables['Series']={}
79                self.virtual_tables['Series'].update({'index 0':''})
80                self.virtual_tables['Series'].update({'index 1':'get Fondos.24'})
81                self.virtual_tables['Fondos_all']={'index 0':'get Fondos.0'}
82                self.virtual_tables['Fondos_all'].update({'index 1':''})
83                self.virtual_tables['Fondos_all'].update({'index 2':''})
84                self.virtual_tables['Fondos_all'].update({'index 3':''})
85                self.virtual_tables['Fondos_all'].update({'index 4':''})
86                self.virtual_tables['Fondos_all'].update({'index 5':''})
87                self.virtual_tables['Fondos_Idiomas']={}
88                self.virtual_tables['Fondos_Idiomas']={'index 0':'get Fondos.0'}
89                self.virtual_tables['Fondos_Idiomas'].update({'index 1':''})
90
91                #Dict whith field transformations
92                self.formatFields={}
93                self.formatFields['TiposLector']={'index 0':'add index 0 7'}
94                self.formatFields['Autores']={'index 1':'value 100=70,value 110=71,value 120=72,value 700=70'}
95                self.formatFields['Ejemplares']={'index 13':'concat 13,14,15'}
96                self.formatFields['Ejemplares'].update({'index 9':'date %m/%d/%y %H:%M:%S %Y-%m-%d %H:%M:%S'})
97#               self.formatFields['Ejemplares'].update({'index 2':'from Fondos_all.3 on 2=3'})
98                self.formatFields['Ejemplares'].update({'index 2':'from Fondos_all.5 on 2=3'})
99                #Replace index 3 with the needed data... Recipes from the other side...
100                self.formatFields['Ejemplares'].update({'index 3':'from Fondos_all.4 on 1=1'})
101                self.formatFields['CDUs']={'index 0':'inc 1 1000'}
102                self.formatFields['Series']={'index 0':'inc 1 1000'}
103                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"'}
104                self.formatFields['Fondos'].update({'index 13':'from Autores.2 on 13=0'})
105                self.formatFields['Fondos'].update({'index 24':'from Series.0 on 24=1'})
106                self.formatFields['Fondos'].update({'index 26':'from Fondos_all.2 on 0=1'})
107                self.formatFields['Fondos_all']={'index 2':'from CDUs.0 on 0=1'}
108                self.formatFields['Fondos_all'].update({'index 3':'from Ejemplares.2 on 1=1'})
109                self.formatFields['Fondos_all'].update({'index 4':'from Fondos.1 on 1=0'})
110                self.formatFields['Fondos_all'].update({'index 5':'add index 3 100'})
111                self.formatFields['Fondos_Idiomas']={'index 1':'from Fondos.9 on 0=0'}
112                self.formatFields['TiposFondo']={'index 0':'value 1=1,value 2=12,else=+100'}
113                self.formatFields['TiposEjemplar']={'index 0':'add index 0 100'}
114
115                #Dict whith special columns
116                self.formatTables={}
117                self.formatTables['CDUs']={'index 1':'uniq'}
118                self.formatTables['Series']={'index 1':'uniq'}
119                self.formatTables['Fondos_all']={'index 1':'from Fondos_CDUs.1 on 0=0'}
120
121
122                #Dict with errors
123                self.error={}
124                #self.error['status']=True
125
126                #Array with process order (including virtual tables)
127#               self.executionOrder=['Ubicaciones','TiposLector','Autores','Editoriales','Cursos','Ejemplares','Series','CDUs','Fondos_all','Fondos','Fondos_Idiomas','TiposFondo']
128                self.executionOrder=['Ubicaciones','TiposLector','Autores','Editoriales','Cursos','Series','CDUs','TiposEjemplar','Fondos_all','Ejemplares','Fondos','Fondos_Idiomas','TiposFondo','Fondos_Autores']
129                #Tmp variables
130                self.workDir='/tmp/.abiesToPmb/'
131                self.tableValuesDict={}
132                self.tmpInc=0
133
134                #Work files
135                self.mdb=''
136                self.sql=''
137                self.sqlFiles=[]
138        #def _init
139
140        def _debug(self,msg):
141                if self.dbg:
142                        print('Migrator: '+str(msg))
143        #def _debug
144
145        def _error(self,code,index=None):
146                #Error Codes
147                #10 -> Table not found
148                #11 -> Error ocurred while importing mdb file
149                #12 -> Error exporting mdb to csv
150                #13 -> Error generating sql file
151                #14 -> Error concatenating sql files
152                #15 -> No source table for virtual table
153                #16 -> Couldn't fetch data from table
154                self.error['status']=False
155                self.error['code']=code
156#               if index:
157#                       if index in self.error.keys():
158#                               self.error[index].append(e)
159#                       else:
160#                               self.error[index]=e
161#               else:
162#                       if 'ERR' in self.error.keys():
163#                               self.error['ERR'].append(e)
164#                       else:
165#                               self.error['ERR']=e
166        #def _error
167
168        ###
169        #Process array executionOrder
170        ###
171        def beginMigration(self,mdbFile,sqlFile):
172
173                self.error['status']=True
174                self.error['code']=""
175                self.mdb=mdbFile
176                self.sql=sqlFile
177                if self.exportMdb():
178                        self.sqlFiles=[]
179                        for abiesTable in self.executionOrder:
180                                self.tmpInc=0
181                                self._debug("Processing "+abiesTable)
182                                self._loadTable(abiesTable)
183                                if not self.error['status']:
184                                        break
185                                pmbTable=self._getTableEquivalence(abiesTable)
186                                if not self.error['status']:
187                                        break
188                                self._generateSql(pmbTable,abiesTable)
189                                if not self.error['status']:
190                                        break
191                        if self.error['status']:
192                                self._debug("Concatenating sql files in an unique file")
193                                self._concatFiles()
194                        else:
195                                self._debug("Errors ocurred")
196                                self._debug(self.error)
197                        self._debug("Files generated for tables "+str(self.executionOrder))
198                else:
199                        self._error(11)
200
201                self._debug("ErrorDict:")
202                self._debug(self.error)
203                return self.error
204        #def beginMigration
205
206        def exportMdb(self):
207                returnValue=None
208                self._debug(self.mdb)
209                if os.path.exists(self.mdb):
210                        try:
211                                cmdOut=subprocess.check_output(['mdb-tables',self.mdb],universal_newlines=True)
212                                if cmdOut:
213                                        self.workDir=tempfile.mkdtemp()+"/"
214                                        tables=cmdOut.strip("\n")
215                                        listTables=tables.split(' ')
216                                        for table in listTables:
217                                                if table!='':
218                                                        cmdOut=subprocess.check_output(['mdb-export','-H','-d|||',self.mdb,table],universal_newlines=True)
219                                                        if cmdOut:
220                                                                f=open (self.workDir+table+".csv",'w')
221                                                                f.writelines(cmdOut)
222                                                                f.close()
223                                        returnValue=True
224                        except Exception as e:
225                                self._error(12)
226                                returnValue=False
227                return returnValue
228        #def exportMdb
229
230        ###
231        #Generates the sql
232        #Input: pmb tableName
233        #Output: Array of sql sentences
234        ###
235        def _generateSql(self,destTable,abiesTable):
236                transformDict=self._checkTransformField(abiesTable)
237                origData=self.tableValuesDict[abiesTable]
238                sqlFile=self.workDir+destTable+".sql"
239                fileName=destTable+".sql"
240                try:
241                        if destTable not in self.blacklist:
242                                f=open (sqlFile,'w')
243                        for line in origData:
244                                pmbColumn=0
245                                strInsertValues=''
246                                for index in self.pmb_tables[destTable]:
247                                        if index!='':
248                                                if transformDict:
249                                                        if index in transformDict.keys():
250                                                                strTransform=transformDict[index]
251#                                                               self._debug("Transforming value "+str(line[index])+" index "+str(index)+" with "+strTransform)
252                                                                line[index]=eval(strTransform)
253                                                tmp=str(line[index]).strip("\n")
254                                                #Clean tmp field
255                                                tmp=tmp.replace('"',' ')
256                                                chkFormat=True
257                                                if (destTable in self.formatPmbColumns):
258                                                        if index in self.formatPmbColumns[destTable]:
259                                                                chkFormat=False
260                                                                if self.formatPmbColumns[destTable][index]=='string':
261                                                                        tmp=str(tmp)
262                                                                        tmp=tmp.lstrip(' ')
263                                                                        tmp=tmp.rstrip(' ')
264                                                                        tmp='"'+tmp+'"'
265                                                                elif self.formatPmbColumns[destTable][index]=='int':
266                                                                        tmp=int(tmp)
267
268                                                if chkFormat:
269                                                        try:
270                                                                int(tmp)
271                                                        except:
272                                                                tmp=tmp.lstrip(' ')
273                                                                tmp=tmp.rstrip(' ')
274                                                                tmp='"'+tmp+'"'
275                                                                pass
276                                        else:
277                                                if (destTable in self.defaultPmbValues):
278                                                        if pmbColumn in self.defaultPmbValues[destTable]:
279                                                                tmp=self.defaultPmbValues[destTable][pmbColumn]
280                                                        else:
281                                                                tmp='""'       
282                                                else:
283                                                        tmp='""'
284                                               
285                                        strInsertValues=strInsertValues+tmp+','
286                                        pmbColumn=pmbColumn+1
287                                strInsertValues=strInsertValues[:-1]
288                                if destTable not in self.blacklist:
289                                        f.write("Insert into "+destTable+" values ("+strInsertValues+");\n")
290                        if destTable not in self.blacklist:
291                                f.close()
292                                self.sqlFiles.append(sqlFile)
293                except Exception as e:
294                        self._error(13)
295
296        #def _generateSql
297
298        ###
299        #Concats all the generated files
300        ###
301        def _concatFiles(self):
302                self._debug("Generating "+self.sql)
303                self._debug("Files list:")
304                self._debug(self.sqlFiles)
305                try:
306                        f=open(self.sql,'w')
307                        f.write("DELETE from docs_location;\n")
308                        f.write("DELETE from indexint;\n")
309                        f.write("DELETE from docs_type where idtyp_doc=1 or idtyp_doc=12;\n")
310                        for sqlFile in self.sqlFiles:
311                                self._debug("Opening "+sqlFile)
312                                a=open(sqlFile,'r')
313                                aContent=a.readlines()
314                                a.close()
315                                f.writelines(aContent)
316                        f.close()
317                except Exception as e:
318                        self._error(14)
319                       
320        #def _concatFile
321
322
323        ###
324        #Loads a table from a file or a virtual table from a bunch of tables
325        #Input: Table name
326        ###
327        def _loadTable(self,tableName):
328                returnValue=False
329                self._debug("Opening "+tableName)
330                fileName=self.workDir+tableName+'.csv'
331                data=[]
332                if os.path.exists(fileName):
333                        try:
334                                f=open(fileName,'r')
335                                lines=f.readlines()
336                                f.close()
337                                for line in lines:
338                                        array=line.split('|||')
339                                        data.append(array)
340                                returnValue=True
341                        except Exception as e:
342                                self._error(10)
343                else: #Check in virtual dict
344                        if tableName in self.virtual_tables.keys():
345                                data=self._loadVirtualTable(tableName)
346                                returnValue=True
347                        else:
348                                self._error(10)
349
350                self.tableValuesDict[tableName]=data
351                if tableName in self.formatTables.keys():
352                        self.tableValuesDict[tableName]=self._checkTransformTables(tableName)
353                return (returnValue)
354        #def _loadTable
355
356        ###
357        #Loads a virtual table as described by virtual tables dict
358        #Input: Table name
359        #Output: Dataset (array of arrays with the virtual table)
360        ###
361        def _loadVirtualTable(self,tableName):
362                self._debug("Loading virtual table "+tableName)
363                data=[]
364                dataDict={}
365                if tableName in self.virtual_tables.keys():
366                        proceed=False
367                        for key,line in self.virtual_tables[tableName].items():
368#                               print (s)ourceData)
369#                               for key,line in sourceData.items():
370                                        if line.startswith('get'):
371                                                proceed=True
372                                                sourceIndex=key.split(' ')[1]
373                                                getFrom=line.split(' ')[1]
374                                                sourceIndex=getFrom.split('.')[1]
375                                                sourceTable=getFrom.split('.')[0]
376                                                dataDict[key]=self._funcGetValueFromTable(sourceTable,sourceIndex)
377                        if proceed:
378                                #Data is charged on the dataDict, time to populate data array
379                                maxLen=0
380                                for key in dataDict.keys():
381                                        columnLen=len(dataDict[key])
382                                        if columnLen>maxLen:
383                                                maxLen=columnLen
384                                index=0
385                                while index<maxLen:
386                                        dataLine=[]
387                                        for key in self.virtual_tables[tableName].keys():
388                                                arrayIndex=int(key.split(' ')[-1])
389                                                if key in dataDict.keys():
390                                                        dataLine.insert(arrayIndex,dataDict[key][index])
391                                                else:
392                                                        dataLine.insert(arrayIndex,'')
393                                        data.append(dataLine)
394                                        index=index+1
395                else:
396                        self._error(15)
397                return(data)
398
399        ###
400        #Finds the pmb table related with an abies table
401        #Input: Table name in abies
402        #Output: pmb table name
403        ###
404        def _getTableEquivalence(self,tableName):
405                pmbTable=None
406                for key in self.pmb_abies.keys():
407                        if tableName in self.pmb_abies[key]:
408                                pmbTable=key
409                                break
410                return pmbTable
411        #def _getTableEquivalence
412
413        ###
414        #Check if there's any transformation to apply to the fields of a table
415        #Input: Abies table name
416        #Output: Dict with field indexes as keys and transformations to apply as values
417        def     _checkTransformField(self,abiesTable):
418                transformDict={}
419                if abiesTable in self.formatFields.keys():
420                        transform=self.formatFields[abiesTable]
421                        self._debug("Transforming fields "+str(transform)+" in "+abiesTable)
422                        for key,line in transform.items():
423                                index=int(key.split(' ')[-1])
424                                if line.startswith('add'):
425                                        transformDict[index]=self._transformAdd(line,index)
426                                elif line.startswith('value'):
427                                        transformDict[index]=self._transformValue(line,index)
428                                elif line.startswith('concat'):
429                                        transformDict[index]=self._transformConcat(line,index)
430                                elif line.startswith('date'):
431                                        transformDict[index]=self._transformDate(line,index)
432                                elif line.startswith('inc'):
433                                        transformDict[index]=self._transformInc(line,index)
434                                elif line.startswith('get'):
435                                        transformDict[index]=self._transformGet(line,index)
436                                elif line.startswith('from'):
437                                        transformDict[index]=self._transformQuery(line,index,abiesTable)
438
439                self._debug("TransformDict: "+str(transformDict))
440                return transformDict
441        #def _checkTransformField
442
443        ###
444        #Transform routines, self-explaining
445        ###
446        def _transformAdd(self,line,index):
447                sourceIndex=line.split(' ')[2]
448                increment=line.split(' ')[-1]
449                returnValue='int(line['+sourceIndex+'])+'+increment
450                return(returnValue)
451
452        def _transformValue(self,line,index):
453                values=line.split(',')
454                tmpStr=''
455                elseValue=None
456                for value in values:
457                        relation=value.split('=')
458                        destValue=relation[-1]
459                        if not relation[0].startswith('else'):
460                                sourceValue=relation[0].split(' ')[-1]
461                                tmpStr=tmpStr+str(destValue)+' if line['+str(index)+']=="'+str(sourceValue)+'" else '
462                        else:
463                                elseValue='str(int(line['+str(index)+']) '+str(destValue)+')'
464                if not elseValue:
465                        elseValue=destValue
466                        try:
467                                int(destValue)
468                                returnValue='('+tmpStr+ '"'+str(elseValue)+'")'
469                        except:
470                                returnValue='('+tmpStr+ ''+str(elseValue)+')'
471                else:
472                        returnValue='('+tmpStr +str(elseValue)+')'
473
474                return(returnValue)
475
476        def _transformConcat(self,line,index):
477                concat=line.split(' ')[-1]
478                concatArray=concat.split(',')
479                tmpStr=''
480                for concatField in concatArray:
481                        tmpStr=tmpStr+'line['+str(concatField)+']+'
482                returnValue=tmpStr[:-1]
483                return(returnValue)
484
485        def _transformDate(self,line,index):
486                dates=line.split(' ')
487                sourceFormat=dates[1]+' '+dates[2]
488                destFormat=dates[3]+' '+dates[4]
489                returnValue='self._funcDateTransform(line['+str(index)+'],"'+sourceFormat+'","'+destFormat+'")'
490                return(returnValue)
491
492        def _funcDateTransform(self,date,origFormat,destFormat):
493                date=date.replace('"','')
494                destFormat=destFormat.replace('"','')
495                returnValue=(datetime.datetime.strptime(date, origFormat).strftime(destFormat))
496                return(returnValue)
497               
498        def _transformInc(self,line,index):
499                increment=line.split(' ')
500                inc=increment[1]
501                base=0
502                if len(increment)==3:
503                        base=int(increment[2])
504                if self.tmpInc<base:
505                        self.tmpInc=base
506                returnValue='self._funcIncrementField('+inc+')'
507                return(returnValue)
508        ###
509        #Some values need a special transformation that requires a helper function.
510        #Those helper functions are the _func...
511        ###
512        def _funcIncrementField(self,inc):
513                self.tmpInc=self.tmpInc+int(inc)
514                returnValue=self.tmpInc
515                return(returnValue)
516
517        def _transformGet(self,line,index):
518                getFrom=line.split(' ')[-1]
519                getFromTable=getFrom.split('.')[0]
520                getFromIndex=getFrom.split('.')[-1]
521                returnValue='self._funcGetValueFromTable('+getFromTable+','+getFromIndex+')'
522                return(returnValue)
523
524        def _funcGetValueFromTable(self,table,index):
525                fileName=self.workDir+table+'.csv'
526                data=[]
527                index=int(index)
528                if os.path.exists(fileName):
529                        try:
530                                f=open(fileName,'r')
531                                lines=f.readlines()
532                                f.close()
533                                for line in lines:
534                                        array=line.split('|||')
535                                        data.append(array[index])
536                        except Exception as e:
537                                self._error(16)
538                else:
539                        self._error(16)
540                return(data)
541
542        def _transformQuery(self,line,index,tableName):
543                self._debug("Join field "+line)
544                transformDict=[]
545                arrayLine=line.split(' ')
546                sourceTableField=arrayLine[1]
547                joinFromTo=arrayLine[-1]
548                sourceTable=sourceTableField.split('.')[0]
549                sourceField=int(sourceTableField.split('.')[1])
550                joinFrom=joinFromTo.split('=')[0]
551                joinTo=joinFromTo.split('=')[1]
552                returnValue='self._funcGetValueFromQuery("'+tableName+'","'+sourceTable+'",line['+str(joinFrom)+'],'+str(joinTo)+','+str(sourceField)+')'
553                return(returnValue)
554
555        def _funcGetValueFromQuery(self,abiesTable,sourceTable,valueFrom,fieldTo,reqFieldIndex):
556                returnValue=''
557                valueFrom=valueFrom.strip("\n")
558                if sourceTable not in self.tableValuesDict:
559                        self._loadTable(sourceTable)
560                for row in self.tableValuesDict[sourceTable]:
561                                #                       print ("Comparing "+str(valueFrom)+" with "+str(row[fieldTo]))
562                        if valueFrom==str(row[fieldTo]).strip("\n"):
563                                returnValue=row[reqFieldIndex]
564                                break
565                return returnValue
566        #Transform fields functions
567
568        ###
569        #Check if there's any Transform to apply to a whole table
570        #Input: abies table
571        #Output: Dataset with the table
572        ###
573        def _checkTransformTables(self,tableName):
574                transformDict={}
575                if tableName in self.formatTables.keys():
576                        transform=self.formatTables[tableName]
577                        for key,line in transform.items():
578                                index=int(key.split(' ')[-1])
579                                if line.startswith('uniq'):
580                                        transformDict=self._transformTableUniq(tableName,index)
581                                if line.startswith('from'):
582                                        transformDict=self._transformTableJoin(tableName,index,line)
583                return transformDict
584        #def _checkTransformTamble
585
586        ###
587        #Function helpers for table transformation. Self-explaining
588        ###
589        def _transformTableUniq(self,tableName,index):
590                self._debug("Uniq items from index "+str(index))
591                transformDict=[]
592                for item in self.tableValuesDict[tableName]:
593                        if item not in transformDict:
594                                transformDict.append(item)
595                return transformDict
596
597        def _transformTableJoin(self,tableName,index,line):
598                self._debug("Join "+line)
599                transformDict=[]
600                arrayLine=line.split(' ')
601                sourceTableField=arrayLine[1]
602                joinFromTo=arrayLine[-1]
603                sourceTable=sourceTableField.split('.')[0]
604                sourceField=int(sourceTableField.split('.')[1])
605                joinFrom=joinFromTo.split('=')[0]
606                joinTo=joinFromTo.split('=')[1]
607                if sourceTable not in self.tableValuesDict:
608                        self._loadTable(sourceTable)
609                #Generate a dict with joinTo as index and required field as value
610                tmpDict={}
611                tmpIndex=int(joinTo)
612                for row in self.tableValuesDict[sourceTable]:
613                        rowIndex=row[tmpIndex]
614                        rowValue=row[sourceField]
615                        tmpDict.update({rowIndex:rowValue})
616
617                #Walk through origin table and insert values from sourceTableDict
618                tmpIndex=int(joinFrom)
619                for row in self.tableValuesDict[tableName]:
620                        rowIndex=row[tmpIndex]
621                        if rowIndex in tmpDict:
622                                row.insert(tmpIndex,tmpDict[rowIndex])
623                        else:
624                                row.insert(tmpIndex,'')
625                        transformDict.append(row)
626                return transformDict
627        #Table transformation function helpers
628
629### MAIN PROGRAM ###
630
631#migration=abies2Pmb()
632#result=migration.beginMigration(sys.argv[1],sys.argv[2])
633#print(result)
Note: See TracBrowser for help on using the repository browser.