Untitled

# -.- coding: utf-8 -.-
from contrib.middleware import get_current_user, set_current_user
from contrib.utils import getLogger
from engine.mq.models import Task
from django.dispatch import receiver
from django.db.models.signals import post_save, post_delete, pre_delete, pre_save
from PyPDF2 import PdfFileMerger, PdfFileReader
import hashlib
import shutil
from rh.models import DigitalDocumentNaturalPerson, DigitalDocument
from ged.models import Arquivo
from rh.utils import notify_employee
# from rh.task.digital_document import create_update_funcional_file
from dateutil.relativedelta import relativedelta
from django.conf import settings
import os
from threading import Thread
import sys
from engine.models import TaskSession
from rh.models import Servidor

sys.setrecursionlimit(15000)


log = getLogger(__name__)

def gerar_ficha_membros():
    membros = Servidor.objects.filter(type_by_possession__in=['MBR', 'MEL', 'MCM', 'MEC', 'MBR2', 'MEL2', 'MCM2', 'MEC2'],ativo=True)
    membro = Servidor.objects.get(matricula = 16177)
    set_current_user('athenas') 
    user = get_current_user()
    try:
        print 'INICIANDO A GERACAO DA FICHA DE - {} '.format(membro)
        start_generate(None,membro,user,user)
        print 'FINALIZANO A GERACAO DA FICHA DE - {} '.format(membro)
    
    except Exception as err:
        print 'erro ao gerar ficha de {} - {}'.format(membro,err)
    


def start_generate(task=None,servidor=None,user=None,user_update=None):
    
    if get_current_user() == None:
        set_current_user(user_update)
        
    
    merged_file = None
    log.info('Atualizando a ficha funcional consolidada <<<<<<<<<<<<<<')
    
    
    
    if task:
        message = u'    RH - Criando nova ficha funcional para servidor : %s...' % servidor
        task.info(message, 1)
        
    
    nome_arquivo_temp = generate_merged_file_pdf_tmp(task,servidor)
    

    # CRIANDO O ARQUIVO NO BANCO
    arquivo = create_file(task,servidor,nome_arquivo_temp)
    url_ext = arquivo.no_logged_permalink()
    merged_file = get_or_create_merged_file(servidor,arquivo)
    merged_file.file = arquivo
    merged_file.name = nome_arquivo_temp
    merged_file.save()

    if task:
        if merged_file:
            message = u'Tudo gerado corretamente'
            task.info(message, 1)
            task.add_file(merged_file.file)
            task.finish_execution()
    
    return merged_file

def get_or_create_merged_file(servidor,arquivo):
    merged_file = None
    document_type = 1100
    query_merge = DigitalDocumentNaturalPerson.objects.filter(employee=servidor,document_type=document_type)
    
    #DELETANDO A FICHA FUNCIONAL ANTIGA CASO ELA EXISTA!
    if query_merge.exists():
        merged_files = query_merge
        for merged_file in merged_files:
            log.info(u' DELETANDO A FICHA FUNCIONA CONSOLIDADA ANTIGA -{}'.format(merged_file))
            merged_file.delete()
    
    merged_file = DigitalDocumentNaturalPerson(file=arquivo)
    merged_file.employee = servidor
    merged_file.document_type = 1100
    
    return merged_file


def get_query_last_update_file(servidor):
    document_type = 1000
    last_update = None
    query_last = DigitalDocumentNaturalPerson.objects.filter(employee=servidor,document_type=document_type)
    query_last = query_last.order_by('modified_at')
    
    return query_last

def verify_merge_file(servidor):
    dict_file = {'merged_file':None,'last_update':None,'to_update':False}
    
    #Ultima ficha funcional digitalizada
    query_last = get_query_last_update_file(servidor)
    last_update = query_last.last().modified_at if query_last.exists() else None

    dict_file['last_update'] = last_update
    #VERIFICA SE EXISTE O ARQUIVO MAIS NOVO
    if last_update:
        # verifica se existe documento mergeado
        query_merged = DigitalDocumentNaturalPerson.objects.filter(employee=servidor,document_type=1100,modified_at__gte=last_update)
        if query_merged.exists():
            merged_file = query_merged.first()
            dict_file['merged_file'] = merged_file
            dict_file['to_update'] = True
            
    return dict_file


def create_file(task,servidor,nome_arquivo):
    
    arquivo = Arquivo()
    arquivo.filename = unicode(nome_arquivo)
    arquivo.mimetype = unicode('application/pdf')
    t = open(settings.UPLOAD_STORE_DIR+'/tmp/'+nome_arquivo, "r").read()
    buf = b''.join(t)
    filename = hashlib.md5(buf).hexdigest()
    arquivo.file = unicode(filename)
    arquivo.user = servidor.user

    if Arquivo.objects.filter(file=arquivo.file).exists():
        arquivo = Arquivo.objects.filter(file=arquivo.file).first()
        arquivo.filename = unicode(nome_arquivo)
    
    fp = arquivo.absolute_path
    tmp_file = os.path.join(settings.UPLOAD_STORE_DIR+'/tmp/', nome_arquivo)

    if not os.path.exists(arquivo.absolute_directory):
        os.makedirs(arquivo.absolute_directory)

    arquivo.save()
    #Copia para diretorio definitivo        
    shutil.copy(tmp_file, fp)

    #Deletar arquivo temporario
    os.remove(tmp_file)
    user = get_current_user()
    
    return arquivo


def generate_merged_file_pdf_tmp(task=None,servidor=None):

    #Pegando todos o novos arquivos que não foram mergeados ainda
    document_type=1000
    arquivos = DigitalDocumentNaturalPerson.objects.filter(employee=servidor,document_type=document_type).order_by('created_at')
    merger = PdfFileMerger()

    if arquivos.exists():
        print 'to aqui'
        try:
            for pdf in arquivos:
                
                if task:
                    message = u'<p>RH - Adicionando arquivo : %s...</p>' % pdf.file
                    task.info(message, 1)
                    
                if validate_file_eof(task,pdf):
                    merger.append(open(pdf.file.absolute_path, 'rb'))
            
            # pasta_temp = settings.PARENT_DIR+'/tmp/'
            pasta_temp = settings.UPLOAD_STORE_DIR+'/tmp/'
            # data = datetime.now() # current date and time
            nome_arquivo = 'FICHA_FUNCIONAL_INDEXADA_MATRICULA_{}.pdf'.format(servidor.matricula)
            nome_arquivo_completo = pasta_temp+nome_arquivo
            
            if not os.path.exists(pasta_temp):
                os.makedirs(pasta_temp)

            with open(pasta_temp+nome_arquivo, 'wb') as fout:
                merger.write(fout)
            

        except Exception as e:
            log.exception(unicode(e))
            if task:
                message = u'<p>RH - Falha ao gerar ficha funcional de servidor para: %s.</p><p>%s</p>' % (servidor, unicode(err))
                task.message = message
                task.state = state
                task.save()
        
        else:
            return nome_arquivo


def validate_file_eof(task=None,digital_document=None):
    if digital_document.file.mimetype =='application/pdf':
        filename = digital_document.file.absolute_path
        if task:
                task.info(u'validando o arquivo {}'.format(digital_document),1)
        try:
            with open(filename, 'rb') as file:
                pdf_reader = PdfFileReader(file)
                num_pages = pdf_reader.numPages
                for page_num in range(num_pages):
                    pdf_page = pdf_reader.getPage(page_num)
                    _ = pdf_page.extractText()  # Tente extrair texto da página
                return True  # Se não houver erro, retorne True
        except PyPDF2.utils.PdfReadError as e:
            msg = "Erro ao ler PDF: {}".format(e)
            if task:
                task.info(msg,3)
                task.finish_execution()
            return False  # Se ocorrer um erro de leitura, retorne False

gerar_ficha_membros()