ErrorZip Procesing

# -*- coding: utf-8 -*-#
#!/usr/bin/env python
from compiler.ast import TryFinally

__author__ = 'Mario Lacunza <mlacunza@gmail.com>'
__version__ = '0.9.0'


import wx
import forms
import oDatabase
import os
import sys
import zipfile
import shutil
import csv
import string

# Implementing frmMain
class tlstadfrmMain(forms.frmMain):
    def __init__(self, parent):
        forms.frmMain.__init__(self, parent)

        #Establece el tipo de OS
        self.OS = os.name

        #Carga los archivos en el path actual
        self.files = os.listdir('.')

        #Obtener path actual
        self.path = os.getcwd()
        self.dirMain.SetDefaultPath(self.path)

        #Se necesita esto para la version Windows
        if self.OS == 'nt':
            self.dirMain.ReCreateTree()

        self.fol = None

        #Crea estructura de folders
        self.crearFoldersBase()

        #Crea el log
        self.cLog = MyLog(self.txtLog)
        self.cLog.DoLogString('Application start...')


    # Handlers for frmMain events.
    def dirMainOnTreeSelChanged(self, event):

        #Esto para cuando se Procesa
        item = self.dirMain.GetFilePath()
        ext = self.getFileExtension(item)
        if ext == '.zip':
            self.ZipFile = item

        #Para cuando WIPO
        self.fol = self.dirMain.GetPath()


    def dirMainOnTreeItemActivated( self, event ):
        # TODO: Implement dirMainOnTreeItemActivated
        pass

    def dirMainOnTreeItemRightClick( self, event ):
        #self.creaMnuDer()
        pass

    def tProcesoOnToolClicked( self, event ):
        self.Procesar()


    def tZipOnToolClicked( self, event ):
        self.CrearWipo()

    def tSalirOnToolClicked( self, event ):
        self.Salir()

    def trefreshOnToolClicked( self, event ):
        self.dirMain.ReCreateTree()

#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------

    def Salir(self):
        self.Destroy()

#-------------------------------------------------------------------------------
    def dbConnet(self, icode):

        self.db = oDatabase.BaseDatos()
        self.db.connect()

        qry = "Select * from codes where IPC = ?"
        val = (icode,)
        rs = self.db.excecute(qry, val)

        return rs

#------------------------------------------------------------------------------

    def CrearWipo(self):
        "Crea la Wipo estructura despues que user ha trabajado files."

        #Valida que user halla seleccionado un folder
        if self.fol == None:
            dlg = wx.MessageDialog(self, 'You need select the folder cantaining the files to be processed!',
                                   'WIPO Process', wx.OK | wx.ICON_INFORMATION)
            dlg.ShowModal()
            dlg.Destroy()

        else:
            wipofolder = self.fol

            #Pregunta al user por el nombre del nuevo WIPO ZIP
            dlg2 = wx.TextEntryDialog(self, 'Write the New WIPO Zip name [Add ONLY de name not ZIP extension]','WIPO Process')

            if dlg2.ShowModal() == wx.ID_OK:
                wipozip_name = dlg2.GetValue()

            dlg2.Destroy()

            try:

                self.cLog.DoLogString("Start Creating Wipo...")
                fzip = self.path + "/files/final/" + wipozip_name + ".zip"

                zf = zipfile.ZipFile(fzip, mode='w', compression = zipfile.ZIP_DEFLATED)
                zf.close()

                nivel = 0
                zfi = None
                oldzip = []

                for path, dirs, files in os.walk(wipofolder):
                    #Obtiene nombre, verifica si tiene word crea un folder
                    print "Path: " + path

                    if string.find(path,'word') > -1:
                        fname = os.path.basename(path) + '.zip'
                        comname = self.path + "/files/final/" + fname

                        if comname not in oldzip:
                            zfi = zipfile.ZipFile(comname, mode='w', compression = zipfile.ZIP_DEFLATED)
                            zf.close()
                            oldzip.append((comname,fname))

                    for f in files:
                        ff = os.path.join(path, f)
                        print ff
                        nivel += 1
                        print nivel

                        if self.getFileExtension(f) == '.csv':
                            zf = zipfile.ZipFile(fzip, mode='a')
                            zf.write(ff,f)
                            zf.close()

                        elif self.getFileExtension(f) == '.rtf':
                            zf = zipfile.ZipFile(fzip, mode='a')
                            zf.write(ff,f)
                            zf.close()

                        elif self.getFileExtension(f) == '.tif':
                            if string.find(path,'word') > -1:
                                zfi = zipfile.ZipFile(comname, mode='a')
                                zfi.write(ff,f)
                                zfi.close()

                for item in oldzip:
                    zf = zipfile.ZipFile(fzip, mode='a')
                    zf.write(item[0], item[1])
                    zf.close()

                    os.remove(item[0])


            except:
                #self.cLog.DoLogString("System Error:" + sys.exc_info()[0])
                print "System Error:", sys.exc_info()[0]
                raise


#------------------------------------------------------------------------------

    def Procesar(self):
        """Procesa el ZIP file. Extrae todos los files del zip."""

        #Nombre del temp folder donde se hace unzip
        tmp_foldername = None

        #Obtengo el nombre del zip+extension
        f=len(self.path)+11
        tmp_foldername = self.ZipFile[f:-4]

        #Path work folder tmp
        tmp_workfolder= self.path + '/files/tmp/'+ tmp_foldername
        #Path pre folder
        tmp_pre = self.path + '/files/pre/'+ tmp_foldername

        #Sino esta creado el dir lo crea
        if not os.path.exists(tmp_workfolder):
            os.makedirs(tmp_workfolder)

        zf = zipfile.ZipFile(self.ZipFile, mode='r')

        self.cLog.DoLogString('Start process...')
        #Recorre el Zip file abriendo y grabando los files
        for filezipped in zf.infolist():
            filename = filezipped.filename
            data = zf.read(filename)

            fout = open(filename, "w")
            fout.write(data)
            fout.close()

            #Mueve el file del root al destino
            shutil.move(filename, tmp_workfolder)

            #Mensaje en el log
            self.cLog.DoLogString('Woking in tmp folder...')
            txt = "New file created --> %s" % filename
            self.cLog.DoLogString(txt)

        #Crea nuevo directorio de trabajo en /files/pre
        if not os.path.exists(tmp_pre):
            os.makedirs(tmp_pre)

        #Busca File CSV para usar codigos IPC se lee todo el csv y se le
        #copia en una lista, porque mientras esta siendo leido es borrado
        #y copiado en memoria, origina error de lectura
        csvfile = self.BuscarCSV(tmp_workfolder)
        csvinfo = self.ReadCSV(csvfile)

        self.cLog.DoLogString('Processing Zips...')
        #Recorre el folder para procesar archivos
        for subdir, dirs, files in os.walk(tmp_workfolder):
            for f in files:
                #Crea folders
                ext = self.getFileExtension(f)

                if not ext=='.csv':
                    cod = f[3:15]
                    cod = cod.upper()
                    rs = self.ObtenerIPC(csvinfo, cod)
                    rcod = rs[0][1]
                    fname = tmp_pre + '/' + cod + '-' + rcod

                    if not os.path.exists(fname):
                        os.makedirs(fname)

                ff = tmp_workfolder + '/' + f

                #Detecta extension y procesa
                ext2 = self.getFileExtension(ff)

                if ext =='.csv':
                    shutil.move(ff, tmp_pre)
                elif ext == '.rtf':
                    shutil.move(ff, fname)
                elif ext == '.zip':
                    #Recorre el Zip file abriendo y grabando los files
                    zff = zipfile.ZipFile(ff, mode='r')
                    for filezipped in zff.infolist():
                        filename2 = filezipped.filename
                        data2 = zff.read(filename2)

                        fout2 = open(filename2, "w")
                        fout2.write(data2)
                        fout2.close()

                        folder = fname + '/' + f[:-4]
                        if not os.path.exists(folder):
                            os.makedirs(folder)

                        shutil.move(filename2, folder)

        #Borra el directorio tmp
        self.cLog.DoLogString('Clean tasks...')
        shutil.rmtree(tmp_workfolder)

        self.cLog.DoLogString('End process...')

#-------------------------------------------------------------------------------
    def ReadCSV(self, csvfile):
        """Obtiene codigos IPC de la base de datos."""
        reader = csv.reader(open(csvfile,'rb'))
        rs = []

        for index, row in enumerate(reader):
            rs.append(row)

        return rs

#-------------------------------------------------------------------------------
    def ObtenerIPC(self, csvinfo, code):
        """Busca Codigo IPC."""
        for row in csvinfo:
            if row[0] == code:
                ipc = row[2]
                ipc = ipc[0:3]
                rs = self.dbConnet(ipc)
                return rs

#------------------------------------------------------------------------------
    def BuscarCSV(self, mpath):
        """Obtiene el CSV file dento de path."""

        for r,d,f in os.walk(mpath):
            for files in f:
                if files.endswith(".csv"):
                    csv = os.path.join(r,files)
                    return csv

#------------------------------------------------------------------------------


    def crearFoldersBase(self):
        """Crea la estructura de folders basica para la app.

        Se ejecuta solo una vez."""

        if not os.path.exists('files'):
        #Establece los folders segun el OS
            if self.OS == 'posix':
                os.makedirs('files')
                os.makedirs('files/tmp')
                os.makedirs('files/pre')
                os.makedirs('files/final')

            elif self.OS == 'nt':
                os.makedirs('files')
                os.makedirs('files\tmp')
                os.makedirs('files\pre')
                os.makedirs('files\final')

#------------------------------------------------------------------------------

    def getFileExtension(self, filename):
        """Helper function for getting a file's extension"""
        # check if directory
        if not os.path.isdir(filename):
            # search for the last period
            index = filename.rfind('.')
            if index > -1:
                return filename[index:]
            return ''
        else:
            return 'directory'

#------------------------------------------------------------------------------
class MyLog(wx.PyLog):
    def __init__(self, textCtrl):
        wx.PyLog.__init__(self)
        self.tc = textCtrl

    def DoLogString(self, message):
        if self.tc:
            self.tc.AppendText(message + '\n')
#------------------------------------------------------------------------------