import datetime
import dateparser
import operator
import functools
import locale
import os
import socket
from models_syscadomar import *
from models_syscadomar import Logger, Veiculos, Configuracoes, state, Infracoes
from models_syscadomar import Jornadas, Motoristas, Fornecedores, Rotas, DespesasAcerto, Fretes
from models_syscadomar import Acertos, FreteTerceiro, LancamentoContas, ChequesOffice, Especies
from models_syscadomar import GrupoContasOffice, LancamentosCaixa, HistoricoLogin, Pneus, Ponto
from models_syscadomar import Itens, ItensEntrada, NfeEntrada, HistoricoItem, SaidasEstoque
from models_syscadomar import Despesas, Funcionarios, ContaCorrenteMotorista, OsExterna, OsInterna
from models_syscadomar import BancosLancamentos
# from main_class import  CPedagio, LancamentosOffice, CAcertos
from flask import session
from dbfread import DBF

# Instancia das configuracoes
config = Configuracoes.objects().first()

#Deeefinição de qual idioma ele vai tratar os valores monetarios
locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')

NUMBERS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

# Dicionario de Meses do ano e quantidade de dias que cada um tem
calendar = {1:31, 2:28, 3:31, 4:30, 5:31, 6:30, 7:31, 8:31, 9:30, 10:31, 11:30, 12:31}

# Dicionario que faz abreviação dos meses para uso nos relatorios de resumo
meses = {
    '01':'jan',
    '02':'fev',
    '03':'Mar',
    '04':'abr',
    '05':'mai',
    '06':'jun',
    '07':'jul',
    '08':'ago',
    '09':'set',
    '10':'out',
    '11':'nov',
    '12':'dez'
}

## os meses por extenso são utilizados nos relatorios
## de diarias e na tela de diarias para melhor visualizar
## qual o mes esta sendo editado

meses_extenso = {
    '01':'Janeiro',
    '02':'Fevereiro',
    '03':'Março',
    '04':'Abril',
    '05':'Maio',
    '06':'Junho',
    '07':'Julho',
    '08':'Agosto',
    '09':'Setembro',
    '10':'Outubro',
    '11':'Novembro',
    '12':'Dezembro',
}

# def analisa_uso_funcoes(value):
    # """
    # Analisa o uso das funcoes e guarda no banco
    # """
    # db = config.functions_usage

    # if function_name in db:
        # db[function_name] = db[function_name] + 1
    # else:
        # db[function_name] = 1

    # config.update(
            # functions_usage = db
            # )

    # config.save()

def validando_configuracoes():
    """
    Validar os dados das configurações do sistema, caso algo errado, gera uma config incial
    E cria o alerta para o usuário fazer a carreção
    """
    config = Configuracoes.objects().first()
    ano = datetime.datetime.now().year

    if config.data_inicio_acerto == '':
        config.data_inicio_acerto = f'01/01/{ ano }'

    if config.usuario_master is None:
        print('Ajustando o usuario master')
        config.usuario_master = 'arejano'

    config.save()

def returnTimeDateBR():

    """ REFATORAR """
    full_date = datetime.datetime.now()
    data = '{}/{}/{}'.format(full_date.day, full_date.month, full_date.year)
    hora = '{}:{}'.format(full_date.hour, full_date.minute)
    return data, hora

def testar_se_numero(value):

    """
    Valida se os caracteres informdos no codigo
    dos veiculos e motoristas é realmente numérico
    """
    if isinstance(value, int):
        pass
    return 000

def placas_tuple(placas):

    """ REFATORAR """
    placas_return = [("", "")]

    for placa in placas:
        placas_return.append((str(placa), str(placa)))

    return placas_return

def fillZerosFive(value):

    """
    Preenche com 0 os valores menores que 5 cadas de 0
    """
    if len(value) < 5:
        while len(value) != 5:
            value="0"+value

    return value

def fillViagem3(value):

    """
    Preenche com 0 os valores menores que 3
    """
    if len(value) < 2:
        while len(value) != 2:
            value="0"+value

    return value

def fillZeros3(value):

    """
    Preenche com 0 os valores menores que 3
    """
    if len(value) < 3:
        while len(value) != 3:
            value="0"+value

    return value

def valida_formato_placa(placa):

    """
    Valida se a placa informada está no formato correto.
    """
    placa_parte_um = placa[:3]
    placa_parte_dois = placa[3:]

    status = []

    for i in placa_parte_um:
        if i in NUMBERS:
            status.append(False)
        else:
            status.append(True)

    for i in placa_parte_dois:
        if i in NUMBERS:
            status.append(True)
        else:
            status.append(False)

    if False in status:
        return False

    return True

def valida_cpf(cpf):

    """
    Valida se o CPF informado está no formado correto
    """
    status = []
    cpf = cpf.replace('.','')
    cpf = cpf.replace('-','')

    if len(cpf) < 11:
        return False

    for i in cpf:
        if i not in NUMBERS:
            status.append(False)
        else:
            status.append(True)
    if False in status:
        return False
    return True

def calcular_tempo(hora_um, hora_dois):
    """
    calula a diferenca entre dois tempos
    REFATORAR
    """
    if len(hora_um) != 5 or len(hora_dois) != 5:
        return ''

    h1h = int(hora_um.split(':')[0])
    h1m = int(hora_um.split(':')[1])
    h2h = int(hora_dois.split(':')[0])
    h2m = int(hora_dois.split(':')[1])
    hora = h2h - h1h
    minuto = h2m - h1m

    if h1m > h2m:
        hora = hora -1
        if h1h != h2h:
            minuto = 60 - abs(minuto)

    if h1m == h2m:
        minuto = 00

    if hora < 10:
        hora = "0{}".format(hora)

    if minuto < 10:
        minuto = "0{}".format(minuto)

    result = "{}:{}".format(hora, minuto)
    result = result.replace('0-','')
    return result

def somar_dois_tempos(hora_um, hora_dois):

    """ Somar tempo """
    h1h = int(hora_um.split(':')[0])
    h1m = int(hora_um.split(':')[1])
    h2h = int(hora_dois.split(':')[0])
    h2m = int(hora_dois.split(':')[1])
    hora = h1h + h2h
    minuto = h1m + h2m

    if minuto > 60:
        hora += 1
        minuto = 60 - abs(minuto)

    if hora < 10:
        hora = "0{}".format(hora)

    if minuto < 10:
        minuto = '0'+str(minuto)
        if isinstance(minuto, str):
            minuto = minuto.replace('-','')

    if int(minuto) > 10:
        if isinstance(minuto, str):
            minuto = minuto.replace('0','')

    if int(minuto) == 10:
        minuto = '10'

    result = "{}:{}".format(hora, minuto)
    result = result.replace('-','')
    return result

def ajusta_ano_data(data):

    return data.replace(data.split('/')[2], data.split('/')[2][2:])

def atualizar_para_proxima_data(data):

    """
    Função refatorada:
    Informar Proxima dada da Jornada
    """
    datetime_str = data
    datetime_object = datetime.datetime.strptime(datetime_str, '%d/%m/%y')
    next_day = datetime_object + datetime.timedelta(days=1)
    return next_day.strftime("%d/%m/%y")

def getMonth(data):
    """
    Retorna apenas o mes de uma data
    """
    data = data.split('/')
    month = data[1]

    return month

def getDay(data):
    """
    Retorna apenas o dia de uma data
    """
    data = data.split('/')
    day = data[0]

    return day

def getYear(data):
    """
    Retorna apenas o ano de uma data
    """
    data = data.split('/')
    year = data[2]

    return year

infracoes = [
        {'sigla': 'PI - IJM', 'data': '22/07/19', 'infracao': 'Registro Mecânico', 'registro': 'IJM', 'media': ''},
        {'sigla': 'PI - IDM', 'data': '22/07/19', 'infracao': 'Registro Mecânico', 'registro': 'IDM', 'media': ''},
        {'sigla': 'PI - IAM', 'data': '22/07/19', 'infracao': 'Registro Mecânico', 'registro': 'IAM', 'media': ''},
        {'sigla': 'PI - IJM', 'data': '23/07/19', 'infracao': 'Registro Mecânico', 'registro': 'IJM', 'media': ''},
        {'sigla': 'PI - IAM', 'data': '25/07/19', 'infracao': 'Registro Mecânico', 'registro': 'IAM', 'media': ''},
        {'sigla': 'PI - IAM', 'data': '26/07/19', 'infracao': 'Registro Mecânico', 'registro': 'IAM', 'media': ''},
        {'sigla': 'DI', 'data': '27/07/19', 'infracao': 'Descanso Irregular', 'registro': 'ID', 'media': '00:25'}
        ]

def cleanInfracoes(infracoes):
    """ REFATORAR """
    datas = []
    infracoes_definitivas = []

    for infra in infracoes:
        if infra['data'] in datas:
            pass
        else:
            datas.append(infra['data'])

    for data in datas:
        temp_infra = []
        counter_re = 0

        for infra in infracoes:
            if infra['data'] == data:
                temp_infra.append(infra)

        for infra in temp_infra:
            if infra['sigla'] == 'RE':
                counter_re += 1

        for infra in temp_infra:
            if infra['sigla'] == 'DI':
                if counter_re != 0:
                    pass
                else:
                    infracoes_definitivas.append(infra)

    for i in infracoes_definitivas:
        infracoes.remove(i)

    return infracoes

def cleanZeros(value):
    if value == '00:00':
        return ""

def vhf(hora):
    """ REFATORAR """
    if hora in ('23:59', '24:00'):
        return ''
    else:
        return hora

def atualiza_numero_viagens():
    """ REFATORAR """
    motoristas = Motoristas.objects().distinct('codigo')
    for motorista in motoristas:
        jornadas = Jornadas.objects(codigo=motorista)
        lista_viagens = []

        for x in jornadas:
            if x.viagem in lista_viagens:
                pass
            else:
                lista_viagens.append(x.viagem)
        nv = str(len(lista_viagens))
        Motoristas.objects.get(codigo=motorista).update(numero_viagens=nv)

def numeroViagens(jornadas):
    """ REFATORAR """
    counter = 0
    lista_jornadas = []

    for jor in jornadas:
        if jor.viagem in lista_jornadas:
            pass
        else:
            lista_jornadas.append(jor.viagem)
            counter +=1

    return counter

def diasEmDR(motorista, month, year):
    """ REFATORAR """
    if len(month) == 1:
        month = "0{}".format(month)

    year = str(year)
    if len(year) == 4:
        year = year[2:]

    jornadas = Jornadas.objects(codigo=motorista, month=month)
    motorista = Motoristas.objects.get(codigo=motorista)

    dias_em_viagem = []
    dias_mes = list(range(1,calendar[int(month)]+1))

    for j in jornadas:
        dias_em_viagem.append(int(j.data.split('/')[0]))

    dias_para_incluir = [x for x in dias_mes if x not in dias_em_viagem]

    for dia in dias_para_incluir:
        if dia < 10:
            dia = "0{}".format(dia)

        data_insert =  "{}/{}/{}".format(dia,month,year)

        nova_jornada = Jornadas(
            cod_registro="999999999999",
            codigo=motorista.codigo,
            nome=motorista.nome,
            veiculo=motorista.placa,
            data_log=str(datetime.datetime.now()),
            user_log="",
            viagem_1='99999',
            viagem_2='99999',
            viagem_3='99',
            viagem="999999999999",
            data=data_insert,
            day=data_insert.split('/')[0],
            month=data_insert.split('/')[1]
            ,year=data_insert.split('/')[2],
            rj1_ini="00:00",
            rj1_fim="24:00",
            rj1_med="24:00",
            rj1_cod="DR",
            rj1_obs="",

            rj2_ini="",
            rj2_fim="",
            rj2_med="",
            rj2_cod="",
            rj2_obs="",
            rj3_ini="",
            rj3_fim="",
            rj3_med="",
            rj3_cod="",
            rj3_obs="",
            rj4_ini="",
            rj4_fim="",
            rj4_med="",
            rj4_cod="",
            rj4_obs="",
            rj5_ini="",
            rj5_fim="",
            rj5_med="",
            rj5_cod="",
            rj5_obs="",
            rj6_ini="",
            rj6_fim="",
            rj6_med="",
            rj6_cod="",
            rj6_obs="",
            rj7_ini="",
            rj7_fim="",
            rj7_med="",
            rj7_cod="",
            rj7_obs="",
            rj8_ini="",
            rj8_fim="",
            rj8_med="",
            rj8_cod="",
            rj8_obs="",
            rj9_ini="",
            rj9_fim="",
            rj9_med="",
            rj9_cod="",
            rj9_obs="",
            rj10_ini="",
            rj10_fim="",
            rj10_med="",
            rj10_cod="",
            rj10_obs="",
            rj11_ini="",
            rj11_fim="",
            rj11_med="",
            rj11_cod="",
            rj11_obs="",
            rj12_ini="",
            rj12_fim="",
            rj12_med="",
            rj12_cod="",
            rj12_obs="",
            rj13_ini="",
            rj13_fim="",
            rj13_med="",
            rj13_cod="",
            rj13_obs="",
            rj14_ini="",
            rj14_fim="",
            rj14_med="",
            rj14_cod="",
            rj14_obs="",
            rj99="24:00",

            obs_diaria="DR_INCLUIDO_AUTOMATICAMENTE_VIA_SISTEMA",
        )
        nova_jornada.save()

def valorHora(salario,horas_mes):
    if type(horas_mes) != int:
        horas_mes =220

    try:
        salario = salario.split(',')[0].replace('.','')
        vh = round(int(salario)/horas_mes,2)
    except:
        vh = '00,00'

    return str(vh)

def cleanJornadas(jornadas):
    j_list = ['999999999999']
    jornadas_return = []

    for j in jornadas:
        if j.viagem in j_list:
            pass
        else:
            j_list.append(j.viagem)
            jornadas_return.append(j)
    return jornadas_return

def infraAppend(infracoes, motorista, jornada):
    numero_viagem = f'{jornada.viagem_1}.{jornada.viagem_2}.{jornada.viagem_3}'
    for i in infracoes:
        sigla = i['sigla']
        data = i['data']
        # infra = i['infracao']
        registro1 = i['registro']
        if type(i['registro']) != str:
            i['registro'] = 'PI'
        registro = i['registro'].replace('PI - ','')
        try:
            media = i['media']
        except:
            media = '00:00'

        identificador_teste = sigla+motorista+str(data.replace('/',''))+str(media.replace(':',''))

        if Infracoes.objects(identificador=identificador_teste):
            pass
        else:
            nova_infra = Infracoes(
                identificador=identificador_teste,
                codigo_motorista=motorista,
                viagem = numero_viagem,
                motorista = pegar_nome_motorista_codigo(codigo=str(motorista)),
                autorizador = jornada.autorizador,
                sigla=i['sigla'],
                data_cadastro_string = data_atual(),
                data_cadastro = objDate(data_atual()),
                data=atualiza_data(data),
                dia=data.split('/')[0],
                mes=data.split('/')[1],
                ano=data.split('/')[2],
                infra=i['infracao'].upper(),
                registro=registro,
                media=media,
                nova_data = objDate(atualiza_data(data)),
            )
            nova_infra.save()

def atualiza_data(data):
    dia = data.split('/')[0]
    mes = data.split('/')[1]
    ano = data.split('/')[2]

    return f'{dia}/{mes}/20{ano}'

def listaMotorista():
    lista_motora = []

    for codigo in Motoristas.objects().distinct('codigo'):
        lista_motora.append(codigo)

    return lista_motora

def atualizaInfracoes():
    lista_motora = []

    for codigo in Motoristas.objects().distinct('codigo'):
        lista_motora.append(codigo)

    for i in lista_motora:
        number = Infracoes.objects(codigo_motorista=i).count()
        Motoristas.objects(codigo=i).update(numero_infracoes=str(number))

limite_rodagem = '5:00'

def leJornadasGlobal(jornadas):
    print('rodando a leitura da jornada')
    resultados = {'dr':'00:00','fj':'00:00','ha':'00:00 ','ia':'00:00','id':'00:00','ij':'00:00','te':'00:00'}
    if jornadas:
        pass
    else:
        jornadas = jornadas(viagem__ne='999999999999')
    infracoes = []
    for jornada in jornadas:
        registro = 1
        almoco = 0

        while registro != 15:
            rj_cod = "rj"+str(registro)+"_cod"
            media = "rj"+str(registro)+"_med"
            testeRegistroGlobal(jornada[str(rj_cod)],jornada[str(media)], jornada, resultados, infracoes)
            testeMecanicoGlobal(jornada[str(rj_cod)], jornada, infracoes)
            registro += 1

            if jornada[str(rj_cod)] == "IA" or jornada[str(rj_cod)] == "IAM":
                almoco = 1

        if almoco == 0:
            if jornada.rj1_cod == "DR" and int(jornada.rj1_fim.split(':')[0]) >= 11:
                pass
            elif jornada.rj1_cod == "IJ":
                pass
            elif int(jornada.rj99.split(':')[0]) <= 13:
                pass
            elif int(jornada.rj1_fim.split(':')[0]) <= 14:
                pass
            elif 'IA' in jornada.obs_diaria:
                pass
            else:
                infra = {"sigla":"PI","data":jornada.data,"infracao":"NÃO POSSUI ALMOÇO","registro":registro,"media":""}
                infracoes.append(infra)

        hora_limite = int(jornada.rj99.split(':')[0])
        minuto_limite = int(jornada.rj99.split(':')[1])
        # jornada_json = jornadas.to_json()

        if hora_limite == 21:
            if minuto_limite >15:
                infra = {"sigla":"JE","data":jornada.data,"infracao":"JORNADA EXCEDIDA","media":jornada.rj99,"registro":str(registro), 'autorizador':jornada.autorizador}
                infracoes.append(infra)
        elif hora_limite > 21 and hora_limite != 24:
            infra = {"sigla":"JE","data":jornada.data,"infracao":"JORNADA EXCEDIDA","media":jornada.rj99,"registro":str(registro), 'autorizador':jornada.autorizador}
            infracoes.append(infra)

    return resultados

def testeRegistroGlobal(registro, media, jornada, resultados, infracoes):
    if len(media) < 5 and media != '24:00':
        media = "00:00"

    # jornada_irregular = 0
    if registro[:2] == "DR":
        resultados['dr'] = somar_dois_tempos(resultados['dr'], media)
    elif registro[:2] == "FJ":
        resultados['id'] = somar_dois_tempos(resultados['id'], media)
    elif registro[:2] == "HA":
        resultados['ha'] = somar_dois_tempos(resultados['ha'], media)
    elif registro[:2] == "IA":
        resultados['ia'] = somar_dois_tempos(resultados['ia'], media)
        hora = media.split(':')[0]
        if int(hora[1]) < 1:
            infra = {"sigla":"AI","data":jornada.data,"infracao":"ALIMENTAÇÃO IRREGULAR","registro":registro,"media":media}
            infracoes.append(infra)
    elif registro[:2] == "ID":
        hora = media.split(':')
        if int(hora[0][0]) == 0 and int(hora[0][1]) == 0:
            if int(hora[1][0]) < 3:
                infra = {"sigla":"DI","data":jornada.data,"infracao":"DESCANSO IRREGULAR","registro":registro,"media":media}
                infracoes.append(infra)
        resultados['id'] = somar_dois_tempos(resultados['id'], media)
    elif registro[:2] == "IJ":
        hora = media.split(':')[0]
        minuto = media.split(':')[1]
        if int(hora) >= int(limite_rodagem.split(':')[0]):# and int(minuto) > 0:
            if media == "05:00":
                pass
            else:
                infra = {"sigla":"RE","data":jornada.data,"infracao":"RODAGEM EXCEDIDA","registro":registro,"media":media}
                infracoes.append(infra)
        resultados['ij'] = somar_dois_tempos(resultados['ij'],media)
        #horas_jornada['horas_trabalhadas'] = somar_dois_tempos(horas_jornada['horas_trabalhadas'],media)
    elif registro[:2] == "TE":
        resultados['te'] = somar_dois_tempos(resultados['te'] ,media)
    else:
        pass

    infraAppend(infracoes,jornada.codigo, jornada)
    return infracoes

def testeMecanicoGlobal(registro,jornada, infracoes):
    if len(registro) == 3:
        if registro[2] == 'M' or registro[2] == 'm':
            reg_str= ("PI - {}").format(registro)
            infra = {"sigla":reg_str,"data":jornada.data,"infracao":"REGISTRO MECÂNICO","registro":registro,"media":""}
            infracoes.append(infra)

def completaDrJornada(codigo_motorista):
    motorista = Motoristas.objects.get(codigo=codigo_motorista)
    jornadas = Jornadas.objects(codigo=codigo_motorista)

def relatorioJornadas(mes):
    motoristas = Motoristas.objects()

    infra = []

    for motora in motoristas:
        counter = Infracoes.objects(codigo_motorista=motora.codigo,mes=mes).count()
        infra.append({"codigo":motora.codigo,"nome":motora.nome,"infras":counter})

    return infra

def novasInfracoes():
    motoristas = Motoristas.objects()

    for motora in motoristas:
        jornadas = Jornadas.objects(codigo=motora.codigo,)
        leJornadasGlobal(jornadas)

##########################################################
##  Inclusão de ponto no momento da inclusao da jornada ##

def refazerPonto():
    jornadas = Jornadas.objects()
    for jor in jornadas:
        inclusao_de_ponto(jor)

def refazerPontoMotorista(motorista):
    jornadas = Jornadas.objects(codigo=motorista)
    for jor in jornadas:
        inclusao_de_ponto(jor)

def ajusteHoraZero(hora):
    if hora[2] == ':' and len(hora) != 5:
        return "{}0".format(hora)
    else:
        return hora

def inclusao_de_ponto(jornada):
    j_list = [jornada]
    numero_viagem = f'{jornada.viagem_1}.{jornada.viagem_2}.{jornada.viagem_3}'
    resultados = leJornadasGlobalPonto(j_list)
    ident = jornada.cod_registro
    motorista = Motoristas.objects.get(codigo=jornada.codigo)

    if Ponto.objects(identificador=ident):
        Ponto.objects(identificador=ident).update(
            viagem = numero_viagem,
            identificador = ident,
            codigo=motorista.codigo,
            nome = motorista.nome,
            data = jornada.data,
            dataLancamento = objDate(jornada.data),
            dia = jornada.day,
            mes = jornada.month,
            ano = jornada.year,
            dr_tempo = resultados['dr'],
            ia_tempo = resultados['ia'],
            ha_tempo = resultados['ha'],
            id_tempo = resultados['id'],
            te_tempo = resultados['te'],
            ij_tempo = ajusteHoraZero(resultados['ij']),
        )
    else:
        novo_ponto = Ponto(
            viagem = numero_viagem,
            identificador = ident,
            codigo=motorista.codigo,
            nome = motorista.nome,
            data = jornada.data,
            dataLancamento = objDate(jornada.data),
            dia = jornada.day,
            mes = jornada.month,
            ano = jornada.year,
            dr_tempo = resultados['dr'],
            ia_tempo = resultados['ia'],
            ha_tempo = resultados['ha'],
            id_tempo = resultados['id'],
            te_tempo = resultados['te'],
            ij_tempo = ajusteHoraZero(resultados['ij']),
        ).save()

    valores = calcula_hora_extra(resultados, motorista)

    jornada.update(
        dr_tempo = resultados['dr'],
        ia_tempo = resultados['ia'],
        ha_tempo = resultados['ha'],
        id_tempo = resultados['id'],
        te_tempo = resultados['te'],
        ij_tempo = ajusteHoraZero(resultados['ij']),
        valor_he_50 = valores['valor_hora_50'],
        valor_he_100 = valores['valor_hora_100'],
        valor_dia = valores['valor_dia'],
        float_valor_he_50 = float_money(valores['valor_hora_50']),
        float_valor_he_100 = float_money(valores['valor_hora_100']),
        float_valor_dia = float_money(valores['valor_dia']),
        horas_extras_50 = valores['horas_extras_50'],
        horas_extras_100 = valores['horas_extras_100']
            )
    jornada.save()

def leJornadasGlobalPonto(jornadas):
    infracoes = []
    resultados = {'dr':'00:00','fj':'00:00','ha':'00:00 ','ia':'00:00','id':'00:00','ij':'00:00','te':'00:00'}
    for jornada in jornadas:
        registro = 1

        while registro != 15:
            rj_cod = "rj"+str(registro)+"_cod"
            media = "rj"+str(registro)+"_med"
            testeRegistroGlobal(jornada[str(rj_cod)],jornada[str(media)], jornada, resultados, infracoes)
            testeMecanicoGlobal(jornada[str(rj_cod)], jornada, infracoes)
            registro += 1

    return resultados

def dataPonto(ponto):
    lista_meses = []
    data_temp = ponto.distinct('data')

    for data in data_temp:
        mes = data.split('/')[1]
        ano = "20{}".format(data.split('/')[2])
        to_insert = {'mes_numero':mes,'mes_desc':meses[mes],'ano':ano}

        if to_insert in lista_meses:
            pass
        else:
            lista_meses.append(to_insert)

    return lista_meses

def horaVSvalor(hora,valor_hora,extra):
    try:
        h = hora.split(':')[0]
        m = int(hora.split(':')[1])
    except:
        h = 0
        m = 0

    valor_hora = float(valor_hora)

    h60 = int(h)*60
    minutos = h60+m

    if extra != 0:
        valor_hora = valor_hora + valor_hora * extra

    resultado = minutos * (valor_hora/ 60)
    resultado =  ("{0:.2f}".format(round(resultado,2))).replace('.',',')

    return "R$ {}".format(resultado)

def sumMoney(*moneyValues, **kwargs):
    result = 0
    for value in moneyValues:
        value = value.replace('R$','')
        value = value.replace(' ','')
        value = value.replace(',','.')
        value = float(value)

        result = result + value

    return "R$ {0:.2f}".format(round(result,2)).replace('.',',')

def atualizaItensNfe(numeroNota):
    quantidadeItens = ItensEntrada.objects(notaFiscal=numeroNota).count()
    NfeEntrada.objects(notaFiscal=numeroNota).update(qtItens=str(quantidadeItens))

def folhaPagamento(ponto, motorista, link_mes):
    totais = []
    datas_lista = []
    total_mes = {'tempo_ij':'00:00',
            'tempo_id':'00:00',
            'tempo_ia':'00:00',
            'tempo_ha':'00:00',
            'tempo_te':'00:00',
            'total_hora50':'00:00',
            'total_hora100':'00:00',
            'total_valor_dia':'0,00',
            'total_vh50':'0,00',
            'total_vh100':'0,00',
            'total_valor_mes':'0,00'
            }

    for reg in ponto:
        total_dia = {
                'data':'',
                'tempo_ij':'00:00',
                'tempo_id':'00:00',
                'tempo_ia':'00:00',
                'tempo_ha':'00:00',
                'tempo_te':'00:00',
                'valordia':'',
                'hora50':'00:00',
                'hora100':'00:00',
                'vh50':'',
                'vh100':'',
                'total_valor_dia':''
                }

        if int(reg.ij_tempo.split(':')[0]) >= 8:
        #if int(reg.ij_tempo.split(':')[0]) >= 8 and int(reg.ij_tempo.split(':')[0]) < 11:
            hora50 = calcular_tempo('08:00', reg.ij_tempo)
            total_dia['hora50'] = hora50
        else:
            hora50 = '00:00'

        if int(reg.ij_tempo.split(':')[0]) >= 10:
            hora100 = calcular_tempo('10:00',reg.ij_tempo)
            total_dia['hora100'] = hora100
            if total_dia['hora50'] == '00:00':
                total_dia['hora50'] = '02:00'
        else:
            hora100 = '00:00'

        if reg.data in datas_lista:
            total_dia['data'] = reg.data
            total_dia['tempo_ij'] = reg.ij_tempo
            total_dia['tempo_id'] = reg.id_tempo
            total_dia['tempo_ia'] = reg.ia_tempo
            total_dia['tempo_ha'] = reg.ha_tempo
            total_dia['tempo_te'] = reg.te_tempo
            total_dia['valordia'] = 'R$ 0,00'
            total_dia['vh50'] = horaVSvalor(total_dia['hora50'],motorista.valor_hora,0.5)
            total_dia['vh100'] = horaVSvalor(total_dia['hora100'],motorista.valor_hora,1.0)
            total_dia['total_valor_dia'] = sumMoney(total_dia['valordia'], total_dia['vh50'] , total_dia['vh100'])

            total_mes['tempo_ij'] = somar_dois_tempos(total_mes['tempo_ij'],reg.ij_tempo)
            total_mes['tempo_id'] = somar_dois_tempos(total_mes['tempo_id'],reg.id_tempo)
            total_mes['tempo_ia'] = somar_dois_tempos(total_mes['tempo_ia'],reg.ia_tempo)
            total_mes['tempo_ha'] = somar_dois_tempos(total_mes['tempo_ha'],reg.ha_tempo)
            total_mes['tempo_te'] = somar_dois_tempos(total_mes['tempo_te'],reg.te_tempo)
            total_mes['total_hora50'] = somar_dois_tempos(total_mes['total_hora50'], hora50)
            total_mes['total_hora100'] = somar_dois_tempos(total_mes['total_hora100'], hora100)
            total_mes['total_vh50'] = sumMoney(total_mes['total_vh50'], total_dia['vh50'])
            total_mes['total_vh100'] = sumMoney(total_mes['total_vh100'], total_dia['vh100'])
            total_mes['total_valor_dia'] = "R$ {}".format(motorista.salario)
            total_mes['total_valor_mes'] = sumMoney(total_mes['total_vh50'],total_mes['total_vh100'],'1826.93')

            totais.append(total_dia)
        else:
            total_dia['data'] = reg.data
            total_dia['tempo_ij'] = reg.ij_tempo
            total_dia['tempo_id'] = reg.id_tempo
            total_dia['tempo_ia'] = reg.ia_tempo
            total_dia['tempo_ha'] = reg.ha_tempo
            total_dia['tempo_te'] = reg.te_tempo
            total_dia['valordia'] = horaVSvalor('08:00',motorista.valor_hora,0)
            total_dia['vh50'] = horaVSvalor(total_dia['hora50'],motorista.valor_hora,0.5)
            total_dia['vh100'] = horaVSvalor(total_dia['hora100'],motorista.valor_hora,1.0)
            total_dia['total_valor_dia'] = sumMoney(total_dia['valordia'], total_dia['vh50'])

            total_mes['tempo_ij'] = somar_dois_tempos(total_mes['tempo_ij'],reg.ij_tempo)
            total_mes['tempo_id'] = somar_dois_tempos(total_mes['tempo_id'],reg.id_tempo)
            total_mes['tempo_ia'] = somar_dois_tempos(total_mes['tempo_ia'],reg.ia_tempo)
            total_mes['tempo_ha'] = somar_dois_tempos(total_mes['tempo_ha'],reg.ha_tempo)
            total_mes['tempo_te'] = somar_dois_tempos(total_mes['tempo_te'],reg.te_tempo)
            total_mes['total_hora50'] = somar_dois_tempos(total_mes['total_hora50'], hora50)
            total_mes['total_hora100'] = somar_dois_tempos(total_mes['total_hora100'], hora100)
            total_mes['total_vh50'] = sumMoney(total_mes['total_vh50'], total_dia['vh50'])
            total_mes['total_vh100'] = sumMoney(total_mes['total_vh100'], total_dia['vh100'])
            total_mes['total_valor_dia'] = "R$ {}".format(motorista.salario)
            total_mes['total_valor_mes'] = sumMoney(total_mes['total_vh50'],'1826.93')

            totais.append(total_dia)
            datas_lista.append(reg.data)

    dias_trabalhados = []
    for data in datas_lista:
        dias_trabalhados.append(int(data.split('/')[0]))

    dias_do_mes = list(range(1,calendar[int(link_mes)]+1))
    dias_em_dr = [i for i in dias_do_mes + dias_trabalhados if i not in dias_do_mes or i not in dias_trabalhados]

    vh50_values = []

    for item in totais:
        vh50_values.append(item['vh50'])

    return totais, total_mes, dias_em_dr

def removeEstoque(codigoItem,quantidade,numero_nota):

    item = Itens.objects.get(codigo=codigoItem)
    if numero_nota == '':
        pass
    else:
        itemEntrada = ItensEntrada.objects.get(codigo=codigoItem,notaFiscal=numero_nota)

    estoqueAtual = int(item.qtEstoque)
    novaQtEstoque = estoqueAtual - int(quantidade)
    novoHistoricoItem(item, 'item removido da nf')

    item.update(qtEstoque=novaQtEstoque)
    return 'Estoque atualizado'

def somaEstoque(codigoItem,quantidade):
    item = Itens.objects.get(codigo=codigoItem)

    estoqueAtual = int(item.qtEstoque)
    novaQtEstoque = estoqueAtual + int(quantidade)
    item.update(qtEstoque=novaQtEstoque)

    return 'Estoque atualizado'

def atualizaStatusNFE():
    today = datetime.datetime.today()
    data_string = "{}/{}/{}".format(today.day,today.month,today.year)
    notasAtivas = NfeEntrada.objects(status='ativa')

    for notas in notasAtivas:
        if notas.dataInclusao != data_string:
            notas.update(status='Fechada')
        else:
            pass

def ajusteValorItensEstoque():
    itens = Itens.objects(valorEstoque=None)
    for i in itens:
        i.update(valorEstoque='0')

    return 'Se 0, valores ajustados'

def returnJustNumbers(value):
    for i in value:
        if i in NUMBERS:
            pass
        else:
            value = value.replace(i,'')

    return value

def refazerEstoqueFunc():
    itens = ItensEntrada.objects()

    for i in itens:
        somaEstoque(i.codigo,i.quantidade)
    return 'Quantidade de Estoque ajustada conforme entradas'

def zerarEstoqueFunc():
    itens = Itens.objects()

    for i in itens:
        i.update(qtEstoque=0)

    return 'Estoque zerado para todos os itens'

def zerarValorEstoqueF():
    itens = Itens.objects()

    for i in itens:
        i.update(valorEstoque='R$ 0,00')

    return 'Valores do Estoque zerados'

def baixaManualEstoque(codigoItem, quantidade):
    item = Itens.objects.get(codigo=codigoItem)
    quantidadeAtual = int(item.qtEstoque)
    qtSaida = float(quantidade)

    novoEstoque = str(quantidadeAtual - qtSaida)

    item.update(qtEstoque=novoEstoque)

def historicoSaidaItem(item, documento):

    item = item

    historico = {
        'data':dataAtual(),
        'dataObj':objDate(dataAtual()),
        'documento':documento,
    }

    item.historicoSaida.append(historico)
    item.save()

    return None

def removeValorEstoque(codigoItem,valor):

    item = Itens.objects.get(codigo=codigoItem)
    if '-' in valor:
        valor.replace('-','')

    valor = locale.atof(valor.strip("R$"))
    valorEstoque = locale.atof(item.valorEstoque.strip("R$"))

    novoValor = valorEstoque - valor

    item.update(valorEstoque=locale.currency(novoValor, grouping=True))

def atualizaValorEstoque(codigoItem,valorSomar):

    item = Itens.objects.get(codigo=codigoItem)
    valorSomar = locale.atof(valorSomar.strip("R$"))
    valorEstoque = locale.atof(item.valorEstoque.strip("R$"))

    novoValor = valorEstoque + valorSomar

    item.update(valorEstoque=locale.currency(novoValor, grouping=True))

def recalcNota(codigo_nota):

    itens = ItensEntrada.objects(notaFiscal=codigo_nota)
    valores_itens = []

    for i in itens:
        valores_itens.append(i.valorTotal)

    return sumMoneyList(valores_itens)

def returnMoney(value):

    return locale.currency(value, grouping=True)

def valueXqt(valor,quantidade):

    if valor == None:
        valor = 'R$ 0,00'

    int_valor = returnInt(valor)
    quantidade = float(quantidade)
    result = int_valor * quantidade

    return returnMoney(result)

def returnInt(value):

    if value == None:
        return 'R$ 0,00'
    else:
        try:
            return locale.atof(value.strip('R$'))
        except:
            return locale.atof(value.strip(''))

def float_money(value):
    if value == None:
        return 'R$ 0,00'
    else:
        try:
            return locale.atof(value.strip('R$'))
        except:
            return locale.atof(value.strip(''))

def ri(value):
    if value == None:
        return 'R$ 0,00'
    else:
        try:
            return locale.atof(value.strip('R$'))
        except:
            return locale.atof(value.strip(''))

def returnMoneyStringVue(value):

    value = value.replace('R$', '')

    try:
        value = value.replace('.','')
        value = value.replace(',','.')
        return locale.currency(float(value), grouping=True)
    except:
        try:
            return returnMoney(value)
        except:
            return 'R$ 0,00'

def returnMoneyString(value):
    try:
        value = value.replace('.','')
        value = value.replace(',','.')
        return locale.currency(float(value), grouping=True)
    except:
        try:
            return returnMoney(value)
        except:
            return ' -- '

def convertJstoMoney(value):
    if len(value) > 5:
        value = value.replace()

    tmp_value = locale.atof(value.strip('R$'))
    return locale.currency(tmp_value, grouping=True)

def recontValorItens():
    itensEntrada = ItensEntrada.objects()

    for i in itensEntrada:
        atualizaValorEstoque(i.codigo, i.valorTotal)

    return 'Valores atualizados'

def novoHistoricoItem(item, tipo_m):
    today = datetime.datetime.today()
    historico_temp = HistoricoItem(
        tipoMovimentacao = tipo_m,
        data = data_atual(),
        dataLog = str(today),
        dia = str(today.day),
        mes = str(today.month),
        ano = str(today.year),
        usuario = session['username'],
        quantidade_inicio_dia = item.qtEstoque,
    )
    item.historico.append(historico_temp)
    item.save()

def proximoCodigoItem():
    itens = Itens.objects().distinct('codigo')

    last_code = itens[-1]
    next_code = int(last_code) + 1
    return fillZerosFive(str(next_code))

def alteraStatusVeiculo(veiculo,status):
    try:
        veiculo = Veiculos.objects.get(placa=veiculo)
        veiculo.update(status=status)
        print (f'Status do veiculo {veiculo.placa}, alterado para {status}')
    except:
        print ('Função não sera executa')

def log_frete(frete, frete_atual):
    if frete.id == frete_atual.id:
        pass

    frete = frete.to_json()
    frete_atual = frete_atual.to_json()

def data_string_log():
    today = datetime.datetime.today()
    data = "{}/{}/{} - {}:{}".format(today.day,today.month,today.year, today.hour, today.minute)
    return data

def logger(log):
    """ Função que inclui um log de alguns registros do sistema """
    Logger(
        data = data_string_log(),
        data_model = obj_date(),
        msg = log,
        user = session['username'],
    ).save()

def mediaPonderada2(codigo_item):
    if codigo_item != "00034":
        item = Itens.objects.get(codigo=codigo_item)
        lista_valores_entrada = ItensEntrada.objects(codigo=item.codigo).distinct('valorUnidade')
        x_entradas = len(lista_valores_entrada)

        try:
            total = sumMoneyList(lista_valores_entrada)
            result = locale.atof(total.strip('R$',)) / x_entradas
            retorno = locale.currency(result, grouping=True)

            item.update(custoMedio=retorno)
        except:
            retorno = 'R$ 0,00'

        return retorno
    else:
        retorno = 'R$ 0,00'

def atualizaMedia():
    itens  = Itens.objects()

    for i in itens:
        valor_em_estoque = i.qtEstoque * returnInt(i.custoMedio)
        i.update(valorEstoque=returnMoney(valor_em_estoque))

    return 'Valor em estoque atualizado para todos os itens'

def atualizaCustoMedio():
    itens  = Itens.objects().distinct('codigo')

    for i in itens:
        mediaPonderada2(i)

    return 'Custo Medio Atualizado para todos os itens do estoque'

def mediaPonderada(itemCodigo): #item teste codigo: 00101

    item = Itens.objects.get(codigo=itemCodigo)
    entradas = ItensEntrada.objects(codigo=item.codigo)
    lista_media = []
    lista_quantidades = []

    for entrada in entradas:
        lista_media.append(locale.atof(entrada.valorUnidade.strip('R$')))
        lista_quantidades.append(int(entrada.quantidade))

    print (lista_media)
    print (lista_quantidades)

def tempFunction1():
    motoristas = Motoristas.objects()

    for m in motoristas:
        try:
            veiculo = Veiculos.objects.get(placa=m.placa)
            veiculo.update(motorista=m.nome.upper())
        except:
            pass

def returnCavaloCarreta(placa):
    print (f'Placa que estamos pesquisando: {placa}')
    veiculo = Veiculos.objects.get(placa=placa)
    tipo_de_veiculo = veiculo.tipoVeiculo.upper()

    if tipo_de_veiculo == 'CAVALO':
        carreta = veiculo.carretaVinculada
        cavalo = veiculo.placa
    else:
        carreta = ''

    if tipo_de_veiculo == 'CARRETA':
        try:
            cavalo = Veiculos.objects.get(carretaVinculada=veiculo.placa).placa
        except:
            cavalo = ''
        carreta = veiculo.placa
    else:
       cavalo = ''

    dict_return = {'tipo':tipo_de_veiculo,'cavalo':cavalo,'carreta':carreta}

    return dict_return

def placasDuplicadas():
    veiculos = Veiculos.objects()

    lista_placas = []
    duplicados = []

    for i in veiculos:
        if i.placa in lista_placas:
            duplicados.append(i.placa)
        else:
            lista_placas.append(i.placa)
    return duplicados

def calcula_litros(litros, valor):
    try:
        litros = testa_litros_zerado(litros)
        valor = returnInt(valor)
        resultado = valor / litros
        resultado = returnMoneyString(resultado)
        return resultado
    except:
        return returnMoneyString(0.0)

def testa_litros_zerado(value):
    print(value)
    if value == '':
        print(value)
        return 0
    elif type(value) == str:
        print(value)
        return float(value)
    else:
        print(value)
        return value

def testaFornecedor(os):
    if os.fornecedor:
        return os.fornecedor
    else:
        return 'OFICINA INTERNA'

def recalcula_valores_os(os):
    """
    Recalcula os valores da mão de obra da OS
    """
    print('rodando recalculo')
    valores_maodeobra = []
    valores_servicos = []
    for servico in os.maodeobra:
        valores_maodeobra.append(servico['valor'])

    for servico in os.servicos:
        valores_servicos.append(servico['valor'])

    total_mao_de_obra = sumMoneyList(valores_maodeobra)
    total_servicos = sumMoneyList(valores_servicos)

    total = returnMoneyString(returnInt(total_mao_de_obra) + returnInt(total_servicos))
    os.update(
            custo_mao_de_obra=sumMoneyList(valores_maodeobra),
            custo_servicos=sumMoneyList(valores_servicos),
            custo=total
            )
    os.save()

def atualiza_despesas_veiculo(os):
    try:
        veiculo = Veiculos.objects.get(placa=os.placa)

        add_dict = {
            'os':os.numero,
            'motorista':os.motorista,
            'valor':os.custo,
            'data':os.dataAbertura,
            'cavalo':os.cavalo,
            'carreta':os.carreta,
            'mecanico':os.mecanico,
            'tipo_menutencao':os.tipoManutencao,
            'fornecedor':os.fornecedor,
            'viagem':os.ultimaViagem,
        }

        if add_dict not in veiculo.despesas:
            veiculo.despesas.append(add_dict)
            veiculo.save()

        servicos = os.servicos
        if len(servicos) != 0:
            for serv in servicos:
                despesa_existe = existe_despesa_servico(os, serv)
                if despesa_existe is False:
                    nova_despesa = Despesas(
                        dataLancamento = objDate(os.dataEncerramento),
                        dataPagamentoObj = objDate(data_atual()),
                        data = os.dataEncerramento,
                        placa = os.placa,
                        despesa = serv.descricaoServico,
                        itemEstoque = serv.descricaoItem,
                        quantidade = float(serv.quantidade),
                        valor = serv.valor_total,
                        fornecedor = testaFornecedor(os),
                        km = 0 if os.km is None else int(os.km),
                        tipoDespesa = 'VEICULO',
                        status = 'PAGO',
                        osVinculada = os.numero,
                    ).save()

        try:
            os.maodeobra
            os_existe = True
        except:
            os_existe = False

        if os_existe == True:
            if len(os.maodeobra) != 0:
                for serv in os.maodeobra:
                    despesa_existe = existe_despesa_maoobra(os, serv)
                    if despesa_existe is False:
                        nova_despesa = Despesas(
                            dataLancamento = objDate(os.dataEncerramento),
                            documento = serv['numero_nota'],
                            data = os.dataEncerramento,
                            placa = os.placa,
                            despesa = serv['descricaoMaoDeObra'],
                            valor = serv['valor'],
                            fornecedor = os.fornecedor,
                            km = 0 if os.km is None else int(os.km),
                            tipoDespesa = 'VEICULO',
                            status = 'PAGO',
                            osVinculada = os.numero,
                        ).save()

        return 'despesa atualizada'
    except:
        print("Veiculo não existe mais")

def existe_despesa_maoobra(os, serv):
    despesa = Despesas.objects(
        documento = serv['numero_nota'],
        data = data_atual(),
        placa = os.placa,
        despesa = serv['descricaoMaoDeObra'],
        valor = serv['valor'],
        fornecedor = os.fornecedor,
        km = 0 if os.km is None else int(os.km),
        tipoDespesa = 'VEICULO',
        status = 'PAGO',
        osVinculada = os.numero,
    )
    if despesa.count() != 0:
        return True
    else:
        return False

def existe_despesa_servico(os, serv):
    despesa = Despesas.objects(
        placa = os.placa,
        despesa = serv['descricaoServico'],
        quantidade = float(serv['quantidade']),
        valor = serv['valor_total'],
        fornecedor = testaFornecedor(os),
        km = 0 if os.km is None else int(os.km),
        tipoDespesa = 'VEICULO',
        status = 'PAGO',
        osVinculada = os.numero,
    )
    if despesa.count() != 0:
        return True
    else:
        return False

def atualizaDespesasVeiculo(os):

    veiculo = Veiculos.objects.get(placa=os.placa)
    data = os.dataEncerramento
    dataLancamento = objDate(os.dataEncerramento)
    dia = data.split('/')[0]
    mes = data.split('/')[1]
    ano = data.split('/')[2]
    numero_os = os.numero

    add_dict = {
            'os':os.numero,
            'motorista':os.motorista,
            'valor':os.custo,
            'data':os.dataAbertura,
            'cavalo':os.cavalo,
            'carreta':os.carreta,
            'mecanico':os.mecanico,
            'tipo_menutencao':os.tipoManutencao,
            'fornecedor':os.fornecedor,
            'viagem':os.ultimaViagem,
            }

    if(add_dict not in veiculo.despesas):
        veiculo.despesas.append(add_dict)
        veiculo.save()

    servicos = os.servicos

    for serv in servicos:
        nova_despesa = Despesas(
            dataLancamento = dataLancamento,
            dataPagamentoObj = dataLancamento,
            data = data,
            placa = os.placa,
            dia = dia,
            mes = mes,
            ano= ano,
            despesa = serv.descricaoServico,
            itemEstoque = serv.descricaoItem,
            quantidade = float(serv.quantidade),
            valor = serv.valor,
            fornecedor = testaFornecedor(os),
            km = int(os.km),
            tipoDespesa = 'VEICULO',
            status = 'PAGO',
            osVinculada = numero_os,
        ).save()

    try:
        os.maodeobra
        os_existe = True
    except:
        os_existe = False

    if os_existe:
        servicos_externos = os.maodeobra
        for serv in os.maodeobra:
            print (os.numero)
            print ('servido externo de mao de obra')
            nova_despesa = Despesas(
                documento = serv['numero_nota'],
                dataLancamento = dataLancamento,
                data = data,
                placa = os.placa,
                dia = dia,
                mes = mes,
                ano= ano,
                despesa = serv['descricaoMaoDeObra'],
                valor = serv['valor'],
                fornecedor = os.fornecedor,
                km = int(os.km),
                tipoDespesa = 'VEICULO',
                status = 'PAGO',
                osVinculada = numero_os,
            ).save()
            print ('despesa externa atualizada')

    return 'despesa atualizada'

def atualizaDespesasVeiculosSimples(veiculo, despesa):

    print ('atualizando despesas do veiculo')
    veiculo = Veiculos.objects.get(placa=veiculo)
    despesa = Despesas.objects.get(id=despesa)
    print (despesa)

    add_dict = {
            'data':despesa.data,
            'tipo_despesa':despesa.despesa,
            'fornecedor':despesa.fornecedor,
            'documento':despesa.documento,
            'valor':despesa.valor,
            'observacao':despesa.observacoes,
            'os':despesa.osVinculada,
            'motorista':veiculo.motorista,
        }
    if(add_dict not in veiculo.despesas):
        veiculo.despesas.append(add_dict)
        veiculo.save()
    return 'Despesa atualizada'

def atualizaCustoOs(os):

    custos = []

    for servico in os.servicos:
        custos.append(servico.valor)

    temp_value = 0

    for i in custos:
        temp_value  = temp_value + returnInt(i)

    os.update(custo=returnMoney(temp_value))
    os.save()

def filtraPonto(motorista, data):

    configuracoes = Configuracoes.objects()[0]

    try:
        mes = data.split('/')[0]
        ano = data.split('/')[1][2:]
        mes_anterior = int(mes) - 1
        # ponto = Ponto.objects(codigo=motorista)
        data = []

        data_inicio = '{}/{}/{}'.format(configuracoes.dia_inicio_ponto,mes_anterior,ano)
        data_final = '{}/{}/{}'.format(configuracoes.dia_final_ponto + 1,mes,ano)

        if mes == '01':
            ano_anterior = str(int(ano) - 1)
            data_inicio = '{}/{}/{}'.format(configuracoes.dia_inicio_ponto,'12',ano_anterior)

        ponto_correto = Ponto.objects(codigo=motorista,dataLancamento__gte=objDate(data_inicio),dataLancamento__lt=objDate(data_final))
        print (data_inicio, data_final)
        for i in ponto_correto:
            data.append(i)

    except:
        data = 'Erro no filtro'

    return data

def pontoConsolidado(data, motorista):

    motora = Motoristas.objects.get(codigo=motorista)
    consolidado = {
        'codigo_motorista':motora.codigo,
        'nome_motorista':motora.nome,
        'ij_tempo':'00:00',
        'dr_tempo':'00:00',
        'ia_tempo':'00:00',
        'ha_tempo':'00:00',
        'id_tempo':'00:00',
        'te_tempo':'00:00',
        'hora_extra':'00:00',
        'valor_hora_extra':'',
    }

    for log in data:
        if int(log.ij_tempo.split(':')[0]) >= 8:
            hora_ex = (returnCompleteTime(diffTime(log.ij_tempo,'08:00' )))
            consolidado['hora_extra'] = somarTempo(consolidado['hora_extra'], hora_ex)

        consolidado['ij_tempo'] = somarTempo(consolidado['ij_tempo'],log.ij_tempo)
        consolidado['dr_tempo'] = somarTempo(consolidado['dr_tempo'],log.dr_tempo)
        consolidado['ia_tempo'] = somarTempo(consolidado['ia_tempo'],log.ia_tempo)
        consolidado['ha_tempo'] = somarTempo(consolidado['ha_tempo'],log.ha_tempo)
        consolidado['id_tempo'] = somarTempo(consolidado['id_tempo'],log.id_tempo)
        consolidado['te_tempo'] = somarTempo(consolidado['te_tempo'],log.te_tempo)

    consolidado = {
        'codigo_motorista':motora.codigo,
        'nome_motorista':motora.nome,
        'ij_tempo':returnCompleteTime(consolidado['ij_tempo']),
        'dr_tempo':returnCompleteTime(consolidado['dr_tempo']),
        'ia_tempo':returnCompleteTime(consolidado['ia_tempo']),
        'ha_tempo':returnCompleteTime(consolidado['ha_tempo']),
        'id_tempo':returnCompleteTime(consolidado['id_tempo']),
        'te_tempo':returnCompleteTime(consolidado['te_tempo']),
        'ij_valor':tempoHora(returnCompleteTime(consolidado['ij_tempo']),motora.salario),
        #'dr_valor':tempoHora(returnCompleteTime(consolidado['dr_tempo']),motora.salario),
        #'ia_valor':tempoHora(returnCompleteTime(consolidado['ia_tempo']),motora.salario),
        #'ha_valor':tempoHora(returnCompleteTime(consolidado['ha_tempo']),motora.salario),
        #'id_valor':tempoHora(returnCompleteTime(consolidado['id_tempo']),motora.salario),
        'te_valor':tempoHora(returnCompleteTime(consolidado['te_tempo']),motora.salario,1.0),
        'hora_extra':returnCompleteTime(consolidado['hora_extra']),
        'valor_hora_extra':tempoHora(returnCompleteTime(consolidado['hora_extra']),motora.salario,1.5),
    }
    consolidado.update({
        'total':sumMoneyList([consolidado['valor_hora_extra'],
                              motora.salario,
                              consolidado['te_valor'],
                              ])
    })
    return consolidado

def tempoHora(tempo, salario, modificador = 1.0):

    horas = int(tempo.split(':')[0]) * 60
    minutos = int(tempo.split(':')[1])
    salario = locale.atof(salario.strip('')) / 220 / 60
    tempo_total = horas + minutos
    valor_hora = (tempo_total * salario) * modificador

    return locale.currency(valor_hora, grouping=True)

def calcularHoraExtra(motorista,tempo):

    config = Configuracoes.objects.get()
    motorista = Motoristas.objects.get(codigo=motorista)

    if int(tempo.split(':')[0]) >= int(config.jornada_minima.split(':')[0]):
        temp_temp =  returnCompleteTime(diffTime(tempo,config.jornada_minima))
        result = tempoHora(temp_temp, motorista.salario, 1.5)
    else:
        result = 'R$ 0,00'

    return result

def somarTempo(t1, t2):

    try:
        h1 = int(t1.split(':')[0])
        m1 = int(t1.split(':')[1])
        hora1 = datetime.timedelta(hours=h1, minutes=m1)
    except:
        hora1 = t1

    h2 = int(t2.split(':')[0])
    m2 = int(t2.split(':')[1])

    hora2 = datetime.timedelta(hours=h2, minutes=m2)

    result = hora1 + hora2

    return result

def diffTime(t1, t2):

    try:
        h1 = int(t1.split(':')[0])
        m1 = int(t1.split(':')[1])
        hora1 = datetime.timedelta(hours=h1, minutes=m1)
    except:
        hora1 = t1

    h2 = int(t2.split(':')[0])
    m2 = int(t2.split(':')[1])

    hora2 = datetime.timedelta(hours=h2, minutes=m2)

    result = hora1 - hora2

    return result

def returnCompleteTime(time):

    time = str(time)
    #time = time.split(',')

    if len(time) > 10:
        dia = time.split(',')[0]
        horas = time.split(',')[1]
        #return dia.split(' ')[0], horas

        dia = int(dia.split(' ')[0])
        hora = horas.split(':')[0]
        minuto = horas.split(':')[1]

        result = dia * 24 + int(hora)

        return "{}:{}:00".format(result,minuto)
    else:
        return time

def somarValoresAdiatamento(values):

    result = 'R$ 0,00'

    for value in values:
        if value == ' -- ':
            value = 'R$ 0,00'
        if len(value) < 1:
            value = 'R$ 0,00'
        try:
            result = locale.atof(result.strip('R$'))
            value = locale.atof(value.strip('R$'))
            result = result + value
            result = locale.currency(result, grouping=True)
        except:
            result = 'R$ 0,00'

    return result

def sumMoneyList(values):

    result = 'R$ 0,00'

    for value in values:
        if value == ' -- ':
            value = 'R$ 0,00'
        try:
            result = locale.atof(result.strip('R$'))
            value = locale.atof(value.strip('R$'))
            result = result + value
            result = locale.currency(result, grouping=True)
        except:
            result = 'R$ 0,00'

    return result

def somaValoresMaoDeObra(os):

    temp = os.maodeobra

    valores = []
    for i in temp:
        valores.append(i['valor'])

    result = sumMoneyList(valores)

    valores.append(os.custo)

    total_custo = sumMoneyList(valores)

    os.update(custo=total_custo)
    os.save()
    return result, total_custo

def validaQtCriticas():
    for i in Itens.objects():
        if i.qtEstoque < i.qtEstoqueCritico:
            msg_alerta = f'Item {i.descricao} está com estoque abaixo do recomendado'
            print (msg_alerta)

            # if Alertas.objects(alerta=msg_alerta):
                # pass
            # else:
                # novo_aviso = Alertas(
                    # data = datetime.datetime.today(),
                    # alerta = msg_alerta,
                    # status = "ativo"
                # ).save()

def sumListNumbers(lista):
    result = 0

    for i in lista:
        try:
            i = float(i)
            result = result + i
        except:
            result = 0

    return result

def cadastroRota(rota):
    """
    Valida se a rota informada no formulario de frete terceido existe no banco de dados, se nao existe
    faz o cadastro conforme informado no formulario
    """
    next_number = Rotas.objects().order_by('-codigo')[0].codigo + 1
    rotas = Rotas.objects().distinct('rota')
    if rota in rotas:
        print ('Rota Existe')
        pass
    else:
        print ('Rota Não existe, esta sendo criada')
        Rotas(
            codigo=next_number,
            rota=rota.upper(),
            media=0.0
        ).save()

def fillDayDate(dia):
    dia = str(dia)
    if len(dia) == 1:
        return '0{}'.format(dia)
    else:
        return dia

def ajustarDatasSaidas():
    saidas = SaidasEstoque.objects()

    for saida in saidas:
        data_saida = '{}/{}/{}'.format(fillDayDate(saida.dia), saida.mes, saida.ano)

        saida.update(data=data_saida)

def returnDateRelatorio(date):

    return "{}/{}/{}".format(fillDayDate(date.day),fillDayDate(date.month),fillDayDate(date.year))

def convert_objdate_string_date(data):
    return data.strftime('%d/%m/%Y')

def converter_data_em_string(data):
    return data.strftime('%d/%m/%Y %H:%M')

def ano_atual():
    today = datetime.datetime.today()
    return fillDayDate(today.year)

def ano_atual_simples():
    today = datetime.datetime.today()
    return fillDayDate(today.year)[2:]

def data_atual():
    today = datetime.datetime.today()
    data_atual = '{}/{}/{}'.format(fillDayDate(today.day), fillDayDate(today.month), fillDayDate(today.year))

    return data_atual

def dataAtual():
    today = datetime.datetime.today()
    data_atual = '{}/{}/{}'.format(fillDayDate(today.day), fillDayDate(today.month), fillDayDate(today.year))

    return data_atual

def return_string_date(data):
    data = '{}/{}/{}'.format(fillDayDate(data.day), fillDayDate(data.month), fillDayDate(data.year))
    return data

def obj_date(data: str = None):
    if data == None:
        return datetime.datetime.utcnow().isoformat()
    else:
        return datetime.datetime.strptime(data, '%d/%m/%Y')

def objDate(date):
    """
    Retorna a data como um objeto timedate
    """
    if date == None:
        return None
    else:
        if  len(date.split('/')[2]) == 2:
            date = '{}/{}/{}'.format(date.split('/')[0],date.split('/')[1],'20'+date.split('/')[2] )
        try:
            return datetime.datetime.strptime(date, '%d/%m/%Y')
        except:
            return datetime.datetime.strptime('01/01/1990', '%d/%m/%Y')

def tipoDespesa():
    tipo_despesas = Despesas.objects().distinct('tipoDespesa')
    lista_despesas = []

    for item in tipo_despesas:
        if item in lista_despesas:
            pass
        else:
            lista_despesas.append(item)

    return lista_despesas

def descobreNumeroNF(despesa):
    print(f"Funcao de que nao faz nada {despesa}")
#     try:
#         os = OsExterna.objects.get(numero=despesa.osVinculada)
#         for servico in os.maodeobra:
#             pass
#     except:
#         pass
#

def relatorioDespesasPorVeiculo(despesas, despesas_oficina = ''):
    vl_total = []
    for i in despesas: vl_total.append(i.valor)
    relatorio = {
        'titulo_relatorio':'RELATÓRIO DE DESPESAS',
        'resumo_veiculos':[],
        'valor_total':sumMoneyList(vl_total),
    }
    lista_veiculos = despesas.distinct('placa')

    for placa in lista_veiculos:
        despesas_veiculo = despesas(placa=placa)

        valores = []
        for i in despesas_veiculo: valores.append(i.valor)

        resumo = {
            'placa':placa.upper(),
            'despesas':[],
            'valor_total':sumMoneyList(valores)
        }
        for desp in despesas_veiculo:
            detalhes_despesa = {
                'data':desp.data,
                'documento':f"OS INTERNA: {desp.osVinculada}" if desp.documento == None else f"OS EXTERNA: {desp.osVinculada}",
                'nota_fiscal':desp.documento if desp.documento != None else "-",
                'despesa':desp.despesa,
                'valor':desp.valor,
                'item':desp.itemEstoque,
                'quantidade':desp.quantidade,
                'km':desp.km,
                'fornecedor':desp.fornecedor,
            }
            if desp.osVinculada == '':
                detalhes_despesa['documento'] = desp.documento
            resumo['despesas'].append(detalhes_despesa)
        relatorio['resumo_veiculos'].append(resumo)

    if despesas_oficina != '':
        valores_oficina = []
        for i in despesas_oficina: valores_oficina.append(i.valor)

        resumo_oficina = {
            'placa':'NAOTEMPLACA',
            'despesas':[],
            'valor_total':sumMoneyList(valores_oficina)
        }
        for desp in despesas_oficina:
            detalhes_despesa = {
                'data':desp.data,
                'documento':desp.osVinculada,
                'despesa':desp.despesa,
                'valor':desp.valor,
                'item':desp.itemEstoque,
                'quantidade':desp.quantidade,
                'km':desp.km,
                'fornecedor':desp.fornecedor,
            }

            resumo_oficina['despesas'].append(detalhes_despesa)
        relatorio['valor_total'] = sumMoneyList({relatorio['valor_total'], resumo_oficina['valor_total']})
        relatorio['resumo_veiculos'].append(resumo_oficina)
    return relatorio

def compareMongoQuery(original, new, usuario):

    diferencas = {
        'data_alteracao':datetime.datetime.today().strftime('%d/%m/%Y - %H:%M:%S'),
        'usuario':usuario,
    }

    for i in original:
        if original[i] == new[i]:
            diferencas[i] = original[i]
        else:
            diferencas[i] = new[i]

    diferencas.pop('id', 'anexo')
    diferencas.pop('historicoAlteracoes')
    diferencas.pop('anexo')

    return diferencas

def createMonths():

    meses_analitico = []
    ano = dataAtual().split('/')[2]
    mes = 1
    for i in calendar:
        dia_inicial = '01'
        dia_final = str(calendar[i])
        meses_analitico.append(('{}/{}/{}-{}/{}/{}'.format(dia_inicial,fillDayDate(mes),ano, dia_final,fillDayDate(mes),ano)))
        mes += 1

    return meses_analitico
    #['01/01/2019-31/01/2019', '01/02/2019-28/02/2019', '01/03/2019-31/03/2019', '01/04/2019-30/04/2019', '01/05/2019-31/05/2019', '01/06/2019-30/06/2019', '01/07/2019-31/07/2019', '01/08/2019-31/08/2019', '01/09/2019-31/09/2019', '01/10/2019-30/10/2019', '01/11/2019-30/11/2019', '01/12/2019-31/12/2019']

def periodoAtual(mes = 0):

    today = datetime.datetime.today()
    if mes == 0:
        mes = today.month
    else:
        mes = fillDayDate(mes)

    periodo = ['01/{}/{}'.format(fillDayDate(int(mes)),today.year),'{}/{}/{}'.format(calendar[int(mes)],fillDayDate(int(mes)),today.year)]
    return periodo

def lista_dias_mes(inicio, final):
    inicio = datetime.datetime.strptime(inicio, '%d/%m/%Y')
    final = datetime.datetime.strptime(final, '%d/%m/%Y')

    dias = []
    dias.append(return_string_date(inicio))

    new_data =  inicio
    while new_data != final:
        new_data =  new_data + datetime.timedelta(days=1)
        dias.append(return_string_date(new_data))

    return dias

def analiticoOficinaExternaMensal(db_class, mes):

    periodo = periodoAtual(mes)
    temp_value = []
    data = db_class.objects(dataLancamento__gte=objDate(periodo[0]),dataLancamento__lt=objDate(periodo[1]),tipoDespesa='VEICULO',fornecedor__ne='OFICINA INTERNA')

    for i in data:
        temp_value.append(i.valor)

    return sumMoneyList(temp_value)

def analiticoOficinaInternaMensal(db_class, mes):

    periodo = periodoAtual(mes)
    temp_value = []
    data = db_class.objects(dataLancamento__gte=objDate(periodo[0]),dataLancamento__lt=objDate(periodo[1]),tipoDespesa='VEICULO',fornecedor='OFICINA INTERNA')

    for i in data:
        temp_value.append(i.valor)

    return sumMoneyList(temp_value)

def analiticoMensal(db_class, mes):

    periodo = periodoAtual(mes)
    temp_value = []
    data = db_class.objects(dataLancamento__gte=objDate(periodo[0]),dataLancamento__lt=objDate(periodo[1]))

    for i in data:
        if db_class == FreteTerceiro:
            temp_value.append(i.valorTotal)
        else:
            temp_value.append(i.valor)

    return sumMoneyList(temp_value)

def analiticoEstoqueMensal():

    itens = Itens.objects()
    temp_value = []

    for i in itens:
        temp_value.append(i.valorEstoque)

    return sumMoneyList(temp_value)

#Pega os valores de toda classe do DB e distribui no periodo de 12 meses
def analiticoAnual(db_class,tipo_despesa='',fornecedor=''):

    list_return = []

    for i in db_class.objects()[0]:
        if 'valor' in i:
            key = i #Define a KEY como o campo que contem a palavra 'valor' na Clase do DB

    meses_analitico = createMonths()

    for month in meses_analitico:
        inicio = objDate(month.split('-')[0])
        fim = objDate(month.split('-')[1])

        if db_class == Despesas:
            if fornecedor == '':
                data = db_class.objects(dataLancamento__gte=inicio,dataLancamento__lt=fim, tipoDespesa=tipo_despesa,fornecedor__ne='OFICINA INTERNA')
                print("Oficina Interna")
            elif tipo_despesa == '':
                data = db_class.objects(dataLancamento__gte=inicio,dataLancamento__lt=fim)
                print("for e Desp Vazio")
            else:
                data = db_class.objects(dataLancamento__gte=inicio,dataLancamento__lt=fim, tipoDespesa=tipo_despesa,fornecedor=fornecedor)
                print("TUDO")
        else:
            data = db_class.objects(dataLancamento__gte=inicio,dataLancamento__lt=fim)

        lista_valores = []

        for i in data:
            lista_valores.append(i[key])

        list_return.append(sumMoneyList(lista_valores))

    return list_return

def analiticoViagensAnual():

    motoristas = Motoristas.objects()

    temp_viagens = []

    for i in motoristas:
        temp_viagens.append(i.numero_viagens)

    return sumListNumbers(temp_viagens)

def aniversariantes():

    funcionarios = Funcionarios.objects(status__ne='inativo').order_by('dataNasc')
    mes_atual = datetime.datetime.today().month
    proximo_mes = mes_atual + 1

    if proximo_mes == 13:
        proximo_mes = 1

    aniversariantes_mes = []
    aniversariantes_proximo_mes = []
    asos_mes = []
    asos_proximo_mes = []
    asos_vencidos = []

    for i in funcionarios:
        mes_nasc = i.dataNasc.month
        mes_aso = i.ultimoASO.month
        if mes_nasc == mes_atual:
            aniversariantes_mes.append({'nome':i.nome,'data_nasc':i.dataNasc.strftime('%d/%m')})
        elif mes_nasc == proximo_mes:
            aniversariantes_proximo_mes.append({'nome':i.nome,'data_nasc':i.dataNasc.strftime('%d/%m')})
        else:
            pass
        if mes_aso == mes_atual:
            asos_mes.append({'nome':i.nome,'data_nasc':i.ultimoASO.strftime('%d/%m')})
        elif mes_aso == proximo_mes:
            asos_proximo_mes.append({'nome':i.nome,'data_nasc':i.ultimoASO.strftime('%d/%m')})
        else:
            pass

        if i.ultimoASO.month < mes_atual:
            asos_vencidos.append({'nome':i.nome,'data_nasc':i.ultimoASO.strftime('%d/%m')})

    aniversariantes_mes = sorted(aniversariantes_mes, key = lambda i: (i['data_nasc']))
    aniversariantes_proximo_mes = sorted(aniversariantes_proximo_mes, key = lambda i: (i['data_nasc']))
    return aniversariantes_mes, aniversariantes_proximo_mes, asos_mes, asos_proximo_mes, asos_vencidos

def graficoDespesasVeiculos():

    # periodos_ano = createMonths()
    periodo_atual= periodoAtual()

    placas = []
    valores = []

    veiculos = Despesas.objects(tipoDespesa='VEICULO',dataLancamento__gte=objDate(periodo_atual[0]), dataLancamento__lt=objDate(periodo_atual[1])).distinct('placa')

    for veiculo in veiculos:
        desp_vei = Despesas.objects(tipoDespesa='VEICULO',dataLancamento__gte=objDate(periodo_atual[0]), dataLancamento__lt=objDate(periodo_atual[1]), placa=veiculo)
        valores_temp = []
        for desp in desp_vei:
            valores_temp.append(desp.valor)

        placas.append(veiculo)
        valores.append(returnInt(sumMoneyList(valores_temp)))

    return placas, valores

def percentModel(obj):

    cheio = 0
    vazio = 0
    for i in obj:
        if obj[i] == '':
            vazio += 1
        else:
            cheio += 1

    result = vazio / cheio
    result = result * 100
    result = 100 - result

    return result

def novaNotificacao(usuario, msg):
    print(usuario, msg)
    # nova_notificacao = Notificacoes(
    #     usuario = usuario,
    #     dataLancamento = objDate(dataAtual()),
    #     dataAbertura = dataAtual(),
    #     msg = msg,
    # ).save()
    # print ('Nova notificacao salva')

def ajusteDataSaidas():

    saidas = SaidasEstoque.objects()

    for saida in saidas:
        if type(saida.data) == datetime.datetime:
            data_correta = '{}/{}/{}'.format(fillDayDate(saida.dia), fillDayDate(saida.mes), fillDayDate(saida.ano))
            saida.update(data=data_correta)

    for saida in saidas:
        if saida.data == '':
            data_correta = '{}/{}/{}'.format(fillDayDate(saida.dia), fillDayDate(saida.mes), fillDayDate(saida.ano))
            saida.update(data=data_correta)
            saida.save()

    for saida in saidas:
        saida.update(dataLancamento=objDate(saida.data))

def listaSaidasEstoque(dataInicial, dataFinal, codigo_item = ''):

    if codigo_item == '':
        lista_itens = Itens.objects(codigo__ne='00000').distinct('codigo')
    else:
        lista_itens = Itens.objects(codigo=codigo_item).distinct('codigo')

    result = []

    for i in lista_itens:
        lista_saidas = []
        item = Itens.objects.get(codigo=i, codigo__ne='00000')
        saidas_temp = SaidasEstoque.objects(codigo=i,dataLancamento__gte=objDate(dataInicial), dataLancamento__lte=objDate(dataFinal))
        for i in saidas_temp:
            lista_saidas.append(i.quantidade)

        result_temp = {
            'codigo':item.codigo,
            'quantidade':float(sumListNumbers(lista_saidas))
        }

        result.append(result_temp)

    return result

def qtSaidasEstoquePeriodo(dataInicial, dataFinal, item):

    saidas = SaidasEstoque.objects(
            codigo=item,
            dataLancamento__gte=objDate(dataInicial),
            dataLancamento__lte=objDate(dataFinal)
            )

    saidas_total = SaidasEstoque.objects(
            codigo=item,
            dataLancamento__gte=objDate(dataInicial),
            dataLancamento__lte=objDate(dataFinal)
            ).sum('quantidade')
    print(f"[{item} - total_saidas: {saidas_total}]")

    temp_saidas = []

    for i in saidas:
        temp_saidas.append(i.quantidade)

    return float(sumListNumbers(temp_saidas))

def quantidade_entradas_estoque_periodo(data_inicial: str, data_final: str, item):

    """ Pesquisa para saber a quantidade em estoque de ITEM na data_final
    :param data_inicial: str informando a data de inicio da query
    :param data_final: str informando a data de final da query
    :param item: codigo do item
    :returns: Quantidade do item em estoque
    """
    entradas = ItensEntrada.objects(codigo=item,dataLancamento__gte=objDate(data_inicial), dataLancamento__lte=objDate(data_final))

    temp_entradas= []

    for i in entradas:
        temp_entradas.append(i.quantidade)

    return float(sumListNumbers(temp_entradas))

def primeiro_estoque() ->  str:

    """
    Valida se o estoque inicial de cada item deve ser atualizado.
    """
    itens = Itens.objects()
    for i in itens:
        if type(i.estoqueInicial) != float:
            i.update(estoqueInicial=0)
    return 'Estoque Atualizado'

def return_int(value):

    if type(value) != int:
        return 0
    else:
        return value

def data_pagamento_aberto(value='None'):

    """
    Valida se a data do pagamento foi informada
    Se sim, retorna a data informada, se não, returna 'Em Aberto'
    """
    if '/' in value:
        return value
    else:
        return 'Em Aberto'

def colocar_pneus():
    with open('pneus.txt', 'r') as f:
        content = f.readlines()
        for i in content:
            if len(i.split('\t')) != 9:
                pass
            else:
                novo_pneu = Pneus(
                    data_entrada_estoque = objDate(dataAtual()),
                    data_entrada_estoque_string = dataAtual(),
                    numero_fogo = i.split('\t')[0],
                    fabricante = i.split('\t')[1],
                    modelo = i.split('\t')[2],
                    dot = int(i.split('\t')[3]),
                    serie = i.split('\t')[4],
                    dimensao = i.split('\t')[5],
                    vida = i.split('\t')[6],
                    data_primeira_movimentacao_string = i.split('\t')[7],
                    data_primeira_movimentacao= objDate(i.split('\t')[7]),
                    valor = i.split('\t')[8],
                )
                novo_pneu.save()

def historico_login(usuario):

    """
    Adiciona ao historico de login do usuário a data e hora do login
    """
    usuario.historico_login.append(
        {
            'data':obj_date(),
            'data_string':dataAtual(),
        }
    )
    usuario.save()
    return 'Historico de Login adicionado com sucesso'

def hora_atual():

    today = datetime.datetime.now()
    return "{}:{}:{}".format(hora_dois_digitos(today.hour), hora_dois_digitos(today.minute), hora_dois_digitos(today.second))

def hora_dois_digitos(valor):

    if len(str(valor)) < 2:
        return '0{}'.format(valor)
    else:
        return valor

def atualizar_km(placa, km):

    veiculo = Veiculos.objects.get(placa=placa)
    try:
        ultimo_km = float(veiculo.historico_km[-1]['km'])
    except:
        ultimo_km = 0

    diferenca_km = float(km) - ultimo_km
    veiculo.historico_km.append(
        {'km':km,'data':dataAtual(),'diferenca_km':diferenca_km}
    )
    veiculo.update(km_atual=float(km))
    veiculo.save()

def teste_hora_portaria(hora):

    if hora == '':
        return hora_atual()
    else:
        return hora

def le_motoristas():

    with open('motoristas.txt', 'r') as f:
        content = f.readlines()
        for i in content:
            print (i)

def cc_motoristas():

    with open('cc_motoristas.txt', 'r') as f:
        content = f.readlines()
        for i in content:
            i = i.split(';')
            nova_cc = ContaCorrenteMotorista(
                data = objDate(i[0]),
                data_string = i[0],
                codigo_motorista = int(i[1]),
                viagem_1 = i[2],
                viagem_2 = i[3],
                viagem_3 = i[4],
                descricao = i[5],
                valor = i[6],
                tipo = i[7],
                usuario = i[8],
                visto = i[9],
                cod_lancamento = i[10]
            )
            nova_cc.save()

        print ('Contas incluidas')

def ccMoney(value):

    try:
        return returnMoney((float(value.replace(',','.').replace('"',''))))
    except:
        return value

def cleanCC():

    cc = ContaCorrenteMotorista.objects()
    for i in cc:
        i.update(valor=ccMoney(i.valor))

    return 'Feito'

def dia_digito(value):

    if int(value) < 10:
        return '0{}'.format(str(value))
    else:
        return value

def dataDBF(data):
    if data == None:
        return None
    else:
        dia = dia_digito(data.day)
        mes = dia_digito(data.month)
        ano = data.year
        return f'{dia}/{mes}/{ano}'

def result_cc(motorista):

    conta = ContaCorrenteMotorista.objects(codigo_motorista=motorista)
    debitos = []
    creditos = []
    for i in conta:
        if i.tipo == 'D':
            debitos.append(i.valor)
        else:
            creditos.append(i.valor)

    total_debitos = sumMoneyList(debitos)
    total_creditos = sumMoneyList(creditos)

    result = returnInt(total_creditos) - returnInt(total_debitos)
    return (returnMoney(result))

def atualizar_cc():

    lista_motoristas = Motoristas.objects().distinct('codigo')
    for i in lista_motoristas:
        motorista = Motoristas.objects.get(codigo=i)
        saldo_cc = result_cc(int(motorista.codigo))
        motorista.update(saldo_cc=saldo_cc)
        motorista.save()

def resultado_frete_mes(mes):

    periodo = periodoAtual(mes)
    valores = []

    fretes = FreteTerceiro.objects(dataLancamento__gte=objDate(periodo[0]),dataLancamento__lte=objDate(periodo[1]))

    for i in fretes:
        valores.append(i.valorTotal)

    return sumMoneyList(valores)

def mes_ext(number):

    if int(number) > 12:
        pass
    else:
        if int(number) < 10:
            number = '0'+str(number)
            return meses_extenso[(number)]
        else:
            return meses_extenso[str(number)]

def contas_mes(periodo = periodoAtual()):

    periodo = [objDate(periodo[0]),objDate(periodo[1])]

    lancamentos_pagos = LancamentoContas.objects(data_baixa__gte=periodo[0], data_baixa__lte=periodo[1],pagar_receber='P').order_by('data')
    lancamentos_receber = LancamentoContas.objects(data_baixa__gte=periodo[0], data_baixa__lte=periodo[1],pagar_receber='R').order_by('data')
    valores_pagos = []
    valores_recebidos = []

    for i in lancamentos_pagos:
        valores_pagos.append(i.valor)

    for i in lancamentos_receber:
        valores_recebidos.append(i.valor)

    total_pago = sumMoneyList(valores_pagos)
    total_recebido = sumMoneyList(valores_recebidos)

    return total_pago, total_recebido, lancamentos_pagos, lancamentos_receber

def atualiza_km(veiculo, novo_km):
    km_atual = veiculo.km_atual

    if novo_km > km_atual:
        veiculo.update(km_atual=novo_km)
        veiculo.kmHistory.append(
            {
                'data':dataAtual(),
                'km':novo_km
            }
        )
        veiculo.save()
        print ('Km sera atualizado')
    elif km_atual == novo_km:
        print ('KM igual, não sera atualizado')
    else:
        print ('KM não sera atualizado, deve gerar um logo para registro do erro')

def cls():

    os.system('clear')

def ajusta_cavalo_carreta():

    cavalos = Veiculos.objects(tipoVeiculo='CAVALO')
    # carretas = Veiculos.objects(tipoVeiculo='CARRETA')

    for i in cavalos:
        if i.carretaVinculada == None:
            print ('vazio')
        else:
            print (f'Cavalo = {i.placa} -- Carreta {i.carretaVinculada}')
            try:
                carreta = Veiculos.objects.get(placa=str(i.carretaVinculada).upper())
                carreta.update(cavalo_vinculado=i.placa)
                print (f'Carreta - {carreta.placa} atualizado')
            except:
                print (f'Algo deu errado, {i.carretaVinculada.upper()} não localizado')

def soma_entradas(data):

    lancamentos = LancamentoContas.objects(data=data,pagar_receber='R')
    valores = []
    for i in lancamentos:
        valores.append(i.valor)

    return sumMoneyList(valores)

def soma_pagamentos(data):

    lancamentos = LancamentoContas.objects(data=data,pagar_receber='P')
    valores = []
    for i in lancamentos:
        valores.append(i.valor)

    return sumMoneyList(valores)

def calcula_saldo(data=None):

    lancamentos = LancamentoContas.objects(data__gte=data,data__lte=objDate(dataAtual()))
    primeiro_lancamento = lancamentos[0]
    data_primeiro_lancamento = primeiro_lancamento.data
    saldo = 0

    datas_pesquisa = []

    for i in lancamentos:
        if i.data in datas_pesquisa:
            pass
        else:
            print (f'Data: {i.data_string} - Recebido = {soma_entradas(i.data)} - Pago = {soma_pagamentos(i.data)}')
            datas_pesquisa.append(i.data)

def get_usuario():

    return Users.objects.get(username=session['login']).fullname

def pega_usuario():

    return session['username']

def remover_frete_acerto(id_acerto, identificador_frete):

    acerto = Acertos.objects.get(id=id_acerto)

    for frete in acerto.fretes:
        if frete['identificador'] == identificador_frete:
            acerto.fretes.remove(frete)
            atualizar_historico_acerto(acerto, f'Frete [{frete}], removido')

    acerto.save()

def remover_pedagio_acerto(id_acerto, identificador_pedagio):

    """
    Remove o pedagio do acerto
    """
    acerto = Acertos.objects.get(id=id_acerto)

    for pedagio in acerto.pedagios:
        if pedagio['identificador'] == identificador_pedagio:
            acerto.pedagios.remove(pedagio)
    acerto.save()

def uso_pedagio(saida, saldo):

    """ Retona o valor do pedagio em formato de dinheiro """
    return returnMoneyString(returnInt(saida)-returnInt(saldo))

def atualizar_historico_acerto(acerto, msg):

    """ Atualiza historico do acerto """
    acerto.historico.append({
        'data':dataAtual(),
        'hora':hora_atual(),
        'usuario':session['username'],
        'historico':msg,
    })
    acerto.save()

def remover_despesa_acerto(id_acerto, identificador_despesa):

    """
    Remove a despesa do Acerto
    """
    acerto = Acertos.objects.get(id=id_acerto)

    for despesa in acerto.despesas:
        if despesa['identificador'] == identificador_despesa:
            acerto.despesas.remove(despesa)
    acerto.save()

def remove_cheque_reembolso(id_acerto, identificador_cheque):

    """
    Remove o cheque de reembolso do acerto
    """
    acerto = Acertos.objects.get(id=id_acerto)

    for cheque in acerto.cheques_reembolso:
        if cheque['identificador'] == identificador_cheque:
            acerto.cheques_reembolso.remove(cheque)
    acerto.save()

def remover_vale_acerto(id_acerto, identificador_vale):

    """
    Remove o vale do acerto
    """
    acerto = Acertos.objects.get(id=id_acerto)

    if acerto.status == 'aberto':
        for vale in acerto.vales:
            if vale['identificador'] == identificador_vale:
                acerto.vales.remove(vale)

        acerto.save()
    else:
        pass

def remover_cheque_acerto(id_acerto, identificador_cheque):

    """
    Remove o cheque do acerto
    """
    acerto = Acertos.objects.get(id=id_acerto)
    if acerto.status == 'aberto':
        for cheque in acerto.cheques:
            if cheque['identificador'] == identificador_cheque:
                acerto.cheques.remove(cheque)
        acerto.save()
    else:
        print('Erro na remoção do cheque')
        pass

def contador_de_acertos(data_inicio):

    """
    FUNÇÃO NÃO UTILIZADA
    Contador de acertos para ser informado na tela inicial
    """
    acertos_counter = {
        'abertos' : Acertos.objects(status='aberto', data__gte=objDate(data_inicio)).count(),
        'lancamento' : Acertos.objects(status='lançamento', data__gte=objDate(data_inicio)).count(),
        'conferencia' : Acertos.objects(
            status='conferência',
            data__gte=objDate(data_inicio)).count(),
        'fechados' : Acertos.objects(status='fechado', data__gte=objDate(data_inicio)).count()
    }

    return acertos_counter

def valor_zerado(valor):

    """
    Retorna o valor zerado caso incorreto
    """
    if 'R$' in valor:
        return valor
    else:
        return 'R$ 0,00'

def returnIntAcerto(value):

    """
    Retorna um valor monetario em inteiros
    """
    if value == None:
        return 'R$ 0,00'
    elif value == ' -- ':
        value = 'R$ 0,00'
    else:
        try:
            return locale.atof(value.strip('R$'))
        except:
            return locale.atof(value.strip(''))

def returnMoneyStringAcerto(value):

    """
    Retorna uma string monetaria quando informado o valor em inteiros ou float
    """
    try:
        value = value.replace('.','')
        value = value.replace('R$','')
        value = value.replace(',','.')
        return locale.currency(float(value), grouping=True)
    except:
        try:
            return returnMoney(value)
        except:
            return ' -- '

def calcula_frete_acerto(total, icms, desconto, pedagio):

    """
    Calcula todos os dados dos fretes dentro de um acerto
    """
    total = returnIntAcerto(total)
    icms = returnIntAcerto(valor_zerado(icms))
    pedagio = returnIntAcerto(valor_zerado(pedagio))
    desconto = returnIntAcerto(valor_zerado(desconto))

    resultado = total - icms - pedagio - desconto
    premio =  6 * resultado / 100

    return [returnMoney(resultado), returnMoney(premio)]

def total_frete_acerto(id_acerto):

    """
    Informa os totais do frete
    FILE: acerto.py
    """
    acerto = Acertos.objects.get(id=id_acerto)

    totais = []
    total_icms = []
    total_pedagio = []

    for frete in acerto.fretes:
        totais.append(frete['valor'])
        if 'R$' in frete['icms']:
            total_icms.append(frete['icms'])

        if 'R$' in frete['pedagio']:
            total_pedagio.append(frete['pedagio'])

    print (sumMoneyList(totais), sumMoneyList(total_icms), sumMoneyList(total_pedagio))

def calcula_resultados_acerto(acerto):

    """
    Calcula os resultados do acerto com o motorista
    FILE: acerto.py
    """
    premios = []
    adiantamentos = []
    despesas = []
    vales = []
    cheques = []
    cheques_r = []
    fretes = []
    if acerto.status == 'aberto':
        for frete in acerto.fretes:
            adiantamentos.append(frete['adiantamento'])
            premios.append(frete['valor_premio'])
            fretes.append(frete['valor_total'])

        for despesa in acerto.despesas:
            despesas.append(despesa['valor'])

        for vale in acerto.vales:
            vales.append(vale['valor'])

        for cheque in acerto.cheques:
            cheques.append(cheque['valor'])

        for cheques_reemb in acerto.cheques_reembolso:
            cheques_r.append(cheques_reemb['valor'])

        acerto.update(
            total_premios=sumMoneyList(premios),
            total_adiantamentos=sumMoneyList(adiantamentos),
            total_despesas=sumMoneyList(despesas),
            total_cheques=sumMoneyList(cheques),
            total_vales=sumMoneyList(vales),
            total_cheques_reembolso = sumMoneyList(cheques_r),
            faturamento = sumMoneyList(fretes)
        )
        acerto.save()

        motorista = [acerto.total_premios,acerto.total_despesas]
        cadomar = [acerto.total_vales, acerto.total_cheques, acerto.total_adiantamentos]
        total_motorista = sumMoneyList(motorista)
        total_cadomar = sumMoneyList(cadomar)

        if returnInt(total_cadomar) > returnInt(total_motorista):
            retornar  = returnInt(total_cadomar) - returnInt(total_motorista)
            resultado_cc = retornar - returnInt(acerto.retornou) + returnInt(sumMoneyList(cheques_r))
            pagador = 'motorista'
        else:
            retornar = returnInt(total_motorista) - returnInt(total_cadomar)
            # resultado_cc = retornar - returnInt(sumMoneyList(cheques_r))
            pagador = 'cadomar'
            if returnInt(acerto.retornou) > retornar:
                resultado_cc = returnInt(acerto.retornou) + returnInt(sumMoneyList(cheques_r)) + retornar
            else:
                resultado_cc = retornar - returnInt(sumMoneyList(cheques_r))

        text_cc = ''
        if pagador == 'motorista':
            if acerto.retornou != 'R$ 0,00':
                if returnInt(acerto.retornou) < retornar:
                    text_cc = 'debitar'
                elif returnInt(acerto.retornou) == retornar:
                    text_cc = 'zerado'
                elif returnInt(acerto.retornou) > retornar and returnInt(sumMoneyList(cheques_r)) > 0:
                    total_teste = retornar + returnInt(sumMoneyList(cheques_r))
                    if total_teste > returnInt(acerto.retornou):
                        text_cc = 'debitar'
                    else:
                        text_cc = 'creditar'
                else:
                    text_cc = 'creditar'
            elif acerto.retornou == 'R$ 0,00':
                text_cc = 'debitar'
        elif pagador == 'cadomar':
            if retornar > returnInt(sumMoneyList(cheques_r)):
                text_cc = 'creditar'
            elif retornar == returnInt(sumMoneyList(cheques_r)):
                text_cc = 'zerado'
            else:
                text_cc = 'debitar'
        elif pagador == '':
            text_cc = ''

        acerto.update(text_cc=text_cc)

        acerto.update(
            total_cadomar=total_cadomar,
            total_motorista=total_motorista,
            retornar=returnMoney(retornar),
            pagador=pagador,
            resultado_cc=returnMoney(resultado_cc)
        )

        acerto.save()
        atualizar_acerto_cc(acerto)

    else:
        return '', 204

def teste_value(value):

    if "-" in value:
        return "R$ 0,00"
    return value

def recalcula_valores_frete(frete):

    """
    Recalcula os valores do frete e retorna
    atualizado
    """
    valor_frete = ri(frete.valor) - ri(frete.icms) - ri(frete.pedagio) - ri(frete.desconto)
    valor_saldo = ri(frete.valor) - ri(teste_value(frete.adiantamento))
    frete.update(frete_mercado=returnMoneyString(valor_frete), saldo = returnMoneyString(valor_saldo))
    frete.save()

    return frete

def testa_reembolso(acerto):

    """
    Testa se o motorista retornou o valor correto
    FILE: acertos.py
    """
    if acerto.pagador == 'motorista':
        if returnInt(acerto.retornou) > returnInt(acerto.retornar):
            print ('Motorista retornou mais do que deveria')

def somar_cheques_reembolso(acerto):

    """
    Soma todos os cheques de reembolso de um acerto
    FILE: acertos.py
    """
    valores = []
    try:
        for cheque in acerto.cheques_reembolso:
            valores.append(cheque.valor)
    except:
        print('Algo de errado não esta certo')

    return sumMoneyList(valores)

def limpar_valor_retorno(valor):

    """ REFATORAR """
    try:
        return valor
    except:
        return 'R$ 0,00'

def atualizar_acerto_cc(acerto):

    """
    Atualizar o retorno do motorista
    FILE: acerto.py
    """
    acerto = Acertos.objects.get(id=acerto.id)
    if acerto.retornou is None or acerto.retornou == '--':
        retornou = '0,00'

    retornou = acerto.retornou
    acerto.update(retornou=retornou)
    acerto.save()

def proximo_acerto():

    """
    Define o numero do proximo acerto

    """
    numero_acertos = Acertos.objects.count()

    if Acertos.objects.get(numero_acerto=numero_acertos):
        print(f'Acerto com o {numero_acertos} já existe, sera lançando o proximo')

def detalhes_frete(id_frete):

    """ REFATORAR """
    id_acerto = id_frete.split('_')[0]
    acerto = Acertos.objects.get(id=id_acerto)

    for frete in acerto.fretes:
        if frete['identificador'] == id_frete:
            return f"""
                Rota: {frete['rota']},
                Valor: {frete['valor']},
                ICMS: {frete['icms']},
                Pedagio: {frete['pedagio']},
                Adiantamento: {frete['adiantamento']},
                Total: {frete['valor_total']},
                Prêmio: {frete['valor_premio']}
                """

def total_cheques_saida():

    """ REFATORAR """
    cheques = []

    acertos = Acertos.objects()

    for acerto in acertos:
        for item in acerto.cheques:
            cheques.append(item['valor'])

    return sumMoneyList(cheques)

def atualizar_vale_acerto(vale):

    """ REFATORAR """
    try:
        acerto = Acertos.objects.get(numero_viagem=vale.viagem)
        for vale_temp in acerto.vales:
            if vale_temp['numero'] == vale.numero:
                vale_temp['valor'] = vale.valor
            else:
                print ('não encontrado')
        acerto.save()

    except:
        print ('Acerto não sera alterado function: atualizar_vale_acerto() ')

def altera_status_pneu(numero_fogo, placa, posicao):

    try:
        veiculo = Veiculos.objects.get(placa=placa)
        pneu_em_uso = veiculo[posicao]
        pneu = Pneus.objects.get(numero_fogo=numero_fogo)
        pneu_remover = Pneus.objects.get(numero_fogo=pneu_em_uso)
        pneu_remover.update(status='disponivel')
        pneu.update(status='vinculado',veiculo_vinculado=placa)
    except:
        pass

    return numero_fogo

def deletar_vale_acerto(vale):

    """
    Deletar o Acerto informado na tela de Acerto.
    Pega o objeto do vale e desmenbra as informações para encontrar o Acerto.
    """
    acerto = Acertos.objects.get(numero_viagem=vale.viagem)

    if acerto.status == 'aberto':
        for vale_temp in acerto.vales:
            if vale_temp['numero'] == vale.numero:
                acerto.vales.remove(vale_temp)
        acerto.save()
    else:
        pass

def getMyIp():

    """ Apenas infor ao IP da maquina que esta rodando o servidor """
    meu_ip = ([l for l in ([ip for ip in socket.gethostbyname_ex(socket.gethostname())[2]
    if not ip.startswith("127.")][:1], [[(s.connect(('8.8.8.8', 53)),
    s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET,
    socket.SOCK_DGRAM)]][0][1]]) if l][0][0])
    return str(meu_ip)

def faturamento_viagens(viagens):

    """ REFATORAR """
    valor_viagens = []
    valor_reembolso = []
    for i in viagens:
        valor_viagens.append(i['faturamento'])
        valor_reembolso.append(i['reembolso'])

    total_faturado = sumMoneyList(valor_viagens)
    total_reembolso = sumMoneyList(valor_reembolso)

    return total_faturado, total_reembolso

def inativar_motoristas(lista):

    """ Função temporaria apenas para desabilitar alguns motoristas """
    for i in lista:
        i = str(i)
        motorista = Motoristas.objects.get(codigo=i)
        motorista.update(status='inativo')

def add_historico_login(usuario):

    """ Adicionando a data e hora do login do usuário ao historico de login deles """
    novo_login = HistoricoLogin(
        usuario=usuario.username,
        data=objDate(dataAtual()),
        data_string=dataAtual()
    )
    usuario.novo_historico_login.append(novo_login)
    usuario.save()

def numero_viagem_acerto(numero_viagem):

    """
    Retorna o numero da viagem em 3 partes
    """
    viagem = numero_viagem.split('.')
    viagem_um = preencher_viagem(viagem[0])
    viagem_dois = preencher_viagem(viagem[1])
    viagem_tres = viagem[2]

    return viagem_um, viagem_dois, viagem_tres

def preencher_viagem(viagem):

    """
    Retorna o numero da viagem com 5 digitos
    """
    while len(viagem) < 5:
        viagem = "0"+viagem

    return viagem

def calcular_media_valor_combustivel(combustivel):

    """ Calcula a media do valor do combustivel e atualiza o valor atual dele """
    quantidade_valores = len(combustivel.historico_valor)

    total = sumMoneyList(combustivel.historico_valor)
    media = returnInt(total) / quantidade_valores
    valor_em_estoque = media * combustivel.quantidade
    combustivel.update(
        valor_atual=returnMoneyString(media),
        valor_em_estoque=returnMoney(valor_em_estoque),
        ultima_atualizacao = dataAtual(),
        hora_ultima_atualizacao = hora_atual(),
        )
    combustivel.save()
    print(combustivel.valor_atual, media, returnMoney(valor_em_estoque))

def processar_xml(filename):

    """ REFATORAR """
    print('Processando arquivo xml')
    print(filename)

def deletar_registros_banco(registros):
    """ REFATORAR """
    for i in registros:
        i.delete()

def valida_data_vazia(data):
    """ Ajusta a data do cabeçalho do acerto caso ela fique vazia """
    if data == '':
        return dataAtual()
    return data

def valida_data_correta(data):
    """ REFATORAR """
    try:
        return [objDate(data), data]
    except:
        return [objDate('01/01/1990'), '01/01/1990']

def define_banco(file):
    """ REFATORAR """
    if 'B2' in file:
        return 'BANRISUL'
    elif 'B3' in file:
        return 'BRADESCO'
    elif 'B4' in file:
        return 'ITAU'
    else:
        return 'BANCO_NÃO_CADASTRADO'

def total_cheques(cheques):

    """ REFATORAR """
    lista_totais = []
    for cheque in cheques:
        lista_totais.append(cheque.valor)
    return sumMoneyList(lista_totais)

def atualizar_dados_cheques(cheques):

    """
    REFATORADO
    """
    for cheque in cheques:
        try:
            lancamento_vinculado = LancamentosCaixa.objects.get(conta_ctr=cheque.caixa_controle)
            print(lancamento_vinculado.grupo_descricao)
        except:
            print('Lançamento não encontrado')

def pega_decricao_grupo(codigo_grupo):

    """ REFATORAR """
    try:
        descricao_grupo = GrupoContasOffice.objects.get(codigo_grupo=codigo_grupo)
        return descricao_grupo.descricao
    except:
        return 'GRUPO_NAO_CADASTRADO'

def valida_historico(cheque):

    """
    Função para analisar o histotiro de um cheque e vincular os dados de cheque a
    um mototirsta ou viagem
    """
    historico = cheque.historico
    if 'REEMB' in historico:
        historico = historico.split()
        for word in historico:
            if '.' in word:
                numero_viagem = word
                n_viagem = refaz_numero_viagem(numero_viagem)
                if Acertos.objects(numero_viagem=n_viagem):
                    acerto = Acertos.objects.get(numero_viagem=n_viagem)
                    cheque.update(
                        motorista=acerto.motorista.upper(),
                        numero_viagem = acerto.numero_viagem
                    )
                    cheque.save()
                else:
                    print('Errei ao pesquisar com REEMBOLSO')
    elif 'SAIDA' in historico:
        historico = historico.split()
        if Veiculos.objects(placa=historico[1]):
            veiculo = Veiculos.objects.get(placa=historico[1])
            cheque.update(motorista=veiculo.motorista.upper())
            cheque.save()
        else:
            print('Errei ao procurar com historico SAIDA')
    else:
        print('Erro generico')

def teste_hist(cheque):

    """ REFATORAR """
    historico = cheque.historico.split()

def atualiza_motorista_cheques(data):

    """ REFATORAR """
    cheques = ChequesOffice.objects(data_baixa__gte=objDate(data))
    for cheque in cheques:
        valida_historico(cheque)

def refaz_numero_viagem(viagem):

    """ REFATORAR """
    try:
        viagem = viagem.split('.')
        v1 = fillZerosFive(viagem[0])
        v2 = fillZerosFive(viagem[1])
        v3 = viagem[2]

        return f'{v1}.{v2}.{v3}'
    except:
        return ''

def atualiza_contas_cheques(cheques):

    """ REFATORAR """
    for cheque in cheques:
        if cheque.grupo_caixa is None:
            print('testando cheque')
            if LancamentoContas.objects(historico__contains=cheque.historico):
                conta = LancamentoContas.objects(historico__contains=cheque.historico).first()
                grupo = conta.grupo
                grupo_descricao = pega_decricao_grupo(conta.grupo)
                conta = conta.conta

                cheque.update(
                    grupo_caixa=grupo,
                    conta_caixa=conta,
                    grupo_caixa_descricao=grupo_descricao,
                )
                cheque.save()
            else:
                pass

def data_pesquisa(data):

    """ REFATORAR """
    if data == '':
        return objDate(data_atual())
    return objDate(data)

def valor_total_lancamentos(lancamentos):

    """ REFATORAR """
    lista_valores = []
    for lancamento in lancamentos:
        lista_valores.append(lancamento.valor)
    return sumMoneyList(lista_valores)

def pega_descricao_especie(especie):

    """ REFATORAR """
    especie = str(especie)
    try:
        especie = Especies.objects.get(codigo=especie).especie
        return especie
    except:
        return 'S/C'

def descobre_numero_cheque_saida(acerto):

    """ REFATORAR """
    veiculo = acerto.placa
    string_consulta = "SAIDA "+ veiculo
    data_saida = acerto.data_string

    try:
        cheque = ChequesOffice.objects(
            data=objDate(data_saida),
            historico__contains=string_consulta
        ).first()

        if cheque.numero_cheque:
            trocar_cheque_saida(acerto)
            acerto.cheques.append(
                {
                    'identificador':'None_1CHEQUE',
                    'despesa':'CHEQUE SAIDA',
                    'numero_cheque':cheque.numero_cheque,
                    'valor':cheque.valor,
                }
            )
            acerto.save()
    except:
        pass

def trocar_cheque_saida(acerto):

    """ REFATORAR """
    if acerto.cheques[0]['identificador'] == 'None_1CHEQUE':
        acerto.cheques.remove(acerto.cheques[0])

def calcular_dias_em_aberto(lancamento):

    """ REFATORAR """
    if lancamento.dias_em_aberto == None:
        try:
            data_prevista = lancamento.data
            data_pagamento = lancamento.data_baixa
            diferenca = data_pagamento - data_prevista
            diff = str(diferenca.days)
            lancamento.update(dias_em_aberto=diff)
            lancamento.save()
        except:
            pass

def somente_numeros(value):

    """ REFATORAR """
    for i in value:
        if i in NUMBERS:
            pass
        else:
            return False
    return True

def pega_cheque(historico):

    """ REFATORAR """
    cheque = ChequesOffice.objects.get(historico=historico)
    return cheque

def ajusta_grupo_conta_cheques(cheques):

    """ REFATORAR """
    for cheque in cheques:
        counter = 0
        if cheque.motorista == None and cheque.numero_cheque != '0':
            if 'REC' in cheque.historico:
                historico = cheque.historico.split()
                if len(historico) > 2:
                    if somente_numeros(historico[2]):
                        lancamentos = LancamentoContas.objects(historico__contains=historico[2])
                        for lan in lancamentos:
                            if 'REC' in lan.historico:
                                counter += 1
                                if counter == 1:
                                    counter += 1
                                    cheque.update(
                                        grupo_caixa=lan.grupo,
                                        grupo_caixa_descricao=pega_decricao_grupo(lan.grupo),
                                        conta_caixa_lancamento=lan.conta,
                                        conta_caixa_descricao=lan.conta_descricao,
                                    )
                                    cheque.save()
                else:
                    pass

def descobrir_motorista_nome(motorista):

    """
    REFATORAR
    Tenta descobrir o nome do motorista.
    """
    try:
        motorista = Motoristas.objects(nome=motorista.upper())
        return motorista.codigo
    except:
        return 'CODIGO_INCORRETO'

def pegar_nome_motorista_codigo(codigo):

    """
    REFATORAR
    """
    try:
        motorista = Motoristas.objects.get(codigo=str(codigo))
        return motorista.nome.upper()
    except:
        return 'MOTORISTA_DESCONHECIDO'

def calcular_faturameno_mensal_motorista(motorista):

    """
    REFATORAR
    Calcula e retorna o faturamento mensal de um motorista
    """
    faturamenro_terceiro = FreteTerceiro.objects(
        motorista=motorista.nome,
        dataLancamento__gte=objDate('01/01/1990'),
        dataLancamento__lte=objDate(periodoAtual()[1])
    )

    total = []

    for i in faturamenro_terceiro:
        total.append(i.valorTotal)

    return sumMoneyList(total)

def ajusta_motorista_acerto(acerto):

    """
    REFATORAR
    Função não utilizada
    """
    try:
        motorista = Motoristas.objects.get(nome_frota=ajusta_espacos(acerto.motorista))
        if acerto.motorista_codigo == None:
            acerto.update(
                    motorista_codigo=motorista.codigo,
                    motorista=ajusta_espacos(acerto.motorista)
                    )
            acerto.save()
    except:
        pass

def ajusta_espacos(motorista):

    """ REFATORAR """
    return motorista.replace('  ', ' ')

def analisa_dados_acerto():

    for acerto in Acertos.objects():
        if acerto.motorista_codigo == None:
            print(f'Acerto não possui o codigo do motorista, M:{acerto.motorista}')

def dados_motorista_acerto(acerto):

    if motorista_existe_db(acerto.motorista.upper()):
        motorista = Motoristas.objects.get(nome_frota=acerto.motorista.upper())
    else:
        pesquisa_completa_motorista(acerto.motorista.upper())

def pesquisa_completa_motorista(nome):

    """ REFATORAR: TESTE DE VALIDAR MOTORISTA EXISTE """
    nome = nome.upper()
    primeiro_nome = nome.split()[0].upper()
    lista_nome_motorista = Motoristas.objects().distinct('nome_frota')

    achados = []

    for motorista in lista_nome_motorista:
        if comparar_tres(nome, motorista):
            motorista = Motoristas.objects.get(nome_frota = motorista)
            achados.append(motorista.nome)

    if len(achados) > 1:
        for i in achados:
            teste = i.split()[0].upper()

            if teste.upper() != primeiro_nome :
                achados.remove(i)
        print(achados)
    else:
        print(f'{nome} ---------------- nao encontrei ninguem')

def motorista_existe_db(nome):

    """ Retorna se Motorista existe no DB """
    if Motoristas.objects(nome_frota=nome):
        return True
    return False

def comparar_tres(a,b):

    """ REFATORAR """
    counter = 0
    a_temp = a.split()
    b_temp = b.split()

    for i in a_temp:
        if i in b_temp:
            b_temp.remove(i)
            counter +=1

    if counter >= 3:
        return True
    else:
        return False

def calcula_custo_os(os_object):

    """
    REFATORAR
    Calula o custo dos itens na OS
    """
    servicos = []
    mao_de_obra = []

    for servico in os_object.servicos:
        servicos.append(servico.valor)

    for mao in os_object.maodeobra:
        mao_de_obra.append(mao['valor'])

    total_servicos = sumMoneyList(servicos)
    total_mao_de_obra = sumMoneyList(mao_de_obra)
    custo_total = returnMoneyString(returnInt(total_servicos)+returnInt(total_mao_de_obra))

    try:
        os_object.update(
                custo=custo_total,
                custo_servicos = total_servicos,
                custo_mao_de_obra = total_mao_de_obra
                )
        os_object.update()
    except:
        pass

def organiza_valores_fretes(fretes):

    """
    REFATORAR
    Organizar os valores dos fretes
    """
    adiantamentos = []
    totais = []
    saldos = []

    for frete in fretes:
        adiantamentos.append(frete.adiantamento)
        totais.append(frete.valorTotal)

        if len(frete.saldo) != 0:
            saldos.append(frete.saldo)
        else:
            saldos.append('R$ 0,00')

    data = {
        'total':somarValoresAdiatamento(totais),
        'total_adiantamento':somarValoresAdiatamento(adiantamentos),
        'total_saldos':somarValoresAdiatamento(saldos)
    }
    return data

def filtrar_fretes_subcontratados(fretes, filtros):

    fretes_filtrados = []
    if filtros['motorista']:
        for frete in fretes:
            if frete.motorista == filtros['motorista']:
                fretes_filtrados.append

def valor_existe(value):

    if '--' in value:
        return 'R$ 0,00'

    return value

def verificar_erros_cadastro_motorista(motorista):

    return None

def valida_inicio_acerto(acerto):

    """ REFATORAR """
    if acerto.hora_acerto == None:
        acerto.update(hora_acerto=hora_atual())
        acerto.save()
    else:
        pass

def atualiza_km_rodado_acerto(km_inicial, km_final):

    """ REFATORAR """
    try:
        return km_final - km_inicial
    except:
        return 0

def validar_km(km):

    """ REFATORAR """
    if km == '':
        return 0
    else:
        return int(km)

def atualizar_roteiro(acerto):

    """ REFATORAR """
    rotas = []
    sep = ' / '
    for frete in acerto.fretes:
        rotas.append(frete['rota'].upper())

    acerto.update(roteiro=sep.join(rotas))
    acerto.save()
    return Acertos.objects.get(id=acerto.id)

def time_string_to_obj_time(time_string):

    """ REFATORAR """
    if time_string == '24:00':
        time_string = '00:00'

    return datetime.datetime.strptime(time_string, '%H:%M').time()

intervalo_minimo = time_string_to_obj_time('00:30')
jornada_maxima = time_string_to_obj_time('05:30')
hora_limite = time_string_to_obj_time('21:15')

def novo_analisa_jornada(jornada):

    """
    REFATORAR
    Deve ser refeito os parametros de analise das infrações.
    """
    registro = 1
    almoco = 0
    ultimo_registro = False
    dados_analise = []

    while registro != 15:
        codigo_registro = f"rj{str(registro)}_cod"
        inicio = f"rj{str(registro)}_ini"
        fim = f"rj{str(registro)}_fim"
        media = f"rj{str(registro)}_med"
        rj_cod_next = f"rj{str(registro+1)}_cod"

        if jornada[str(rj_cod_next)] == '':
            ultimo_registro = True

        if jornada[str(codigo_registro)] != '':
            dados = {
                'codigo':jornada[str(codigo_registro)],
                'hora_inicio':jornada[str(inicio)],
                'hora_fim':jornada[str(fim)],
                'media':jornada[str(media)],
                'obj_hora_inicio':time_string_to_obj_time(str(jornada[str(inicio)])),
                'obj_hora_fim':time_string_to_obj_time(str(jornada[str(fim)])),
                'obj_hora_media':time_string_to_obj_time(str(jornada[str(media)])),
            }
            registro +=1
            dados_analise.append(dados)

    analisa_dados_jornada(jornada, dados_analise)

def analisa_dados_jornada(jornada, dados):

    """
    REFATORAR
    Função para validar os horarios do motorista, se foi antes
    ou depois do meio dia, serve para criar as infrações analisando o tempo de descanço
    """
    pre_meio_dia = []
    pos_meio_dia = []
    for data in dados:
        if data['obj_hora_fim'] < time_string_to_obj_time('12:00'):
            pre_meio_dia.append(data)
        else:
            pos_meio_dia.append(data)

def remover_obj_frete(identificador):

    """
    Remove o obj frete vinculado ao acerto
    """
    try:
        Fretes.objects.get(identificador_simples=identificador).delete()
    except:
        pass

def deleta_fretes_antigos(fretes):

    """
    REFATORAR
    Não tenho real ideia do que essa função esta fazendo
    """
    for frete in fretes:
        frete = Fretes.objects.get(id=frete.id).delete()

def cria_frete_db(acerto, frete):

    """
    Recebe o frete da função importa_frete_acerto(),
    """
    novo_frete = Fretes(
        identificador_simples = frete['identificador'],
        data_criacao = obj_date(),
        viagem = acerto.numero_viagem,
        codigo_motorista = descobrir_motorista_nome(acerto.motorista),
        icms = frete['icms'],
        motorista = acerto.motorista,
        cavalo = acerto.placa,
        rota = frete['rota'],
        pedagio = frete['pedagio'],
        valor = frete['valor'],
        adiantamento = frete['adiantamento'],
        desconto = frete['desconto'],
        frete_mercado = frete['valor_total'],
        saldo = calcula_saldo_frete(frete['valor'], frete['adiantamento']),
        status = 'aberto',
    ).save()
    acerto.fretes_documentos.append(novo_frete)
    adiciona_frete_veiculo(novo_frete)
    acerto.save()

def update_frete_obj(acerto, frete):

    """
    Atualiza o objeto Frete selecionado no DB.
    A função é chamada em importa_frete_acerto()
    """
    valor_total = frete['valor_total']
    frete_update = Fretes.objects.get(identificador_simples=frete['identificador'])
    frete_update.update(
        icms = frete['icms'],
        rota = frete['rota'],
        pedagio = frete['pedagio'],
        valor = frete['valor'],
        adiantamento = frete['adiantamento'],
        desconto = frete['desconto'],
        frete_mercado = valor_total,
        saldo = calcula_saldo_frete(frete['valor'], frete['adiantamento']),
        status = 'aberto',
    )
    frete_update.save()
    acerto.fretes_documentos.append(frete_update)

def importa_despesas_acerto(acerto):

    """
    Atualiza as despesas do acerto no DB
    """
    for despesa in acerto.despesas:
        if DespesasAcerto.objects(identificador = despesa['identificador']):
            print('despesa existe no banco de dados')
        else:
            criar_despesa(despesa, acerto)

def criar_despesa(despesa, acerto):

    """
    Cria a despesa para cada despesa simples informada no Acerto em lançamento.
    """
    despesa_temporaria = DespesasAcerto(
        identificador = despesa['identificador'],
        valor = despesa['valor'],
        codigo = despesa['despesa'],
    ).save()
    acerto.despesas_documentos.append(despesa_temporaria)
    acerto.save()

def calcula_saldo_frete(valor, adiantamento):

    """ Calcula o saldo do frete.
    """
    if '-' in valor:
        valor = 'R$ 0,00'
    if '-' in adiantamento:
        adiantamento = 'R$ 0,00'

    saldo = returnInt(valor) - returnInt(adiantamento)
    return returnMoneyString(saldo)

def importa_frete_acerto(acerto):

    """
    Usa o identificador_simples para validar se o frete existe,
    se não, cria, se existe, deve atualizar.
    """
    if len(acerto.fretes_documentos) != 0:
        acerto.fretes_documentos = []

    fretes = acerto.fretes

    for frete in fretes:
        if Fretes.objects(identificador_simples=frete['identificador']):
            update_frete_obj(acerto, frete)
        else:
            cria_frete_db(acerto, frete)

def adiciona_frete_veiculo(frete):

    """
    Adiciona o frete criado ao historico de fretes do veiculo
    """
    try:
        veiculo = Veiculos.objects.get(placa=frete.cavalo)
        if frete in veiculo.fretes:
            pass
        else:
            veiculo.fretes.append(frete)
            veiculo.save()
    except:
        pass

def adiciona_acerto_ao_veiculo(acerto):

    """
    Testa se o acerto já existe no veiculo, se não, ele adiciona o acerto
    e roda a função para calcular a media e adicionar ao registro do veiculo.
    """
    try:
        veiculo = Veiculos.objects.get(placa=acerto.placa)
        if acerto in veiculo.acertos:
            pass
        else:
            veiculo.acertos.append(acerto)
            veiculo.save()
    except:
        pass

def calcular_tempo_em_descarga(frete):
    """ Calcula o tempo em descarga dos fretes no acerto """
    try:
        frete = refaz_data_inicio_descarga(frete)
        resultado = frete.data_fim_descarga - frete.data_inicio_descarga
        print(resultado, type(resultado))
        frete.update(
            tempo_em_descarga_string=str(resultado).replace('days','dias').replace('day','dia'),
            tempo_em_descarga = resultado,
        )
        frete.save()
    except:
        pass
def ajusta_peso_frete(peso):

    """ Ajuste simples no peso dos fretes no acerto """
    if peso == None or peso == "":
        return 0.0
    return peso

def somar_lista_float(lista):

    """ Simple float list sum """
    total = 0

    for i in lista:
        total += i

    return "{:.3f}".format(total)

def refaz_data_inicio_descarga(frete):

    """ REFATORAR """
    data_inicio = frete.data_inicio_descarga
    hora_inicio = frete.hora_inicio_descarga

    time_string = f"{convert_objdate_string_date(data_inicio)} {hora_inicio}:00"
    date_time_obj = datetime.datetime.strptime(time_string, '%d/%m/%Y %H:%M:%S')

    data_fim = frete.data_fim_descarga
    hora_fim = frete.hora_fim_descarga

    time_string_fim = f"{convert_objdate_string_date(data_fim)} {hora_fim}:00"
    date_time_obj_fim = datetime.datetime.strptime(time_string_fim, '%d/%m/%Y %H:%M:%S')

    frete.update(data_inicio_descarga=date_time_obj, data_fim_descarga=date_time_obj_fim)
    frete.save()
    frete_atualizado = Fretes.objects.get(id=frete.id)
    return frete_atualizado

def calcular_dias_em_viagem(acerto):

    """
    CALCULAR OS DIAS EM VIAGEM DE UM ACERTO.
    """
    if acerto.data_saida is not None and acerto.data_retorno is not None:
        try:
            resultado = acerto.data_retorno - acerto.data_saida
            acerto.update(dias_em_viagem=str(resultado.days))
            print(f'dias em viagem {resultado}')
            acerto.save()
        except:
            pass
    else:
        pass

def calcular_icms_total_fretes(acerto):

    """
    Calular o ICMS do ACERTO
    """
    try:
        lista_icms = []

        for frete in acerto.fretes_documentos:
            lista_icms.append(frete.icms)

        acerto.update(total_icms=sumMoneyList(lista_icms))
        acerto.save()
    except:
        pass

def calcular_descontos_total_fretes(acerto):

    """ CALCULA DESCONTO TOTAL DO ACERTO """
    try:
        lista_valores = []

        for frete in acerto.fretes_documentos:
            lista_valores.append(frete.desconto)

        acerto.update(total_descontos=sumMoneyList(lista_valores))
        acerto.save()
    except:
        pass

def calcula_peso_total_acerto(acerto):

    """ CALCULA PESO TOTAL DO ACERTO """
    try:
        lista_pesos = []
        for frete in acerto.fretes_documentos:
            lista_pesos.append(float(ajusta_peso_frete(frete.peso)))

        total = somar_lista_float(lista_pesos)
        total_string = "{:.3f}".format(float(total))
        acerto.update(
            peso_total=total,
            peso_total_string = total_string
        )
        acerto.save()
    except:
        pass

def calcular_pedagio_total_fretes(acerto):

    """ Caldula peso total do acerto """
    try:
        lista_pedagio = []

        for frete in acerto.fretes_documentos:
            lista_pedagio.append(frete.pedagio)

        acerto.update(total_pedagio=sumMoneyList(lista_pedagio))
        acerto.save()
    except:
        pass

def remove_despesa_do_acerto(acerto, id_despesa):

    """ Remove despesas do acerto """
    for despesa in acerto.despesas_documentos:
        if str(despesa.id) == id_despesa:
            acerto.despesas_documentos.remove(despesa)
            acerto.save()

def remove_valor_recebido_acerto(acerto, id_valor_recebido):

    """ Remove valor recebido do acerto """
    for valor_recebido in acerto.recebidos:
        if str(valor_recebido.id) == id_valor_recebido:
            acerto.recebidos.remove(valor_recebido)
            acerto.save()

def validar_campo_manual_string(value):

    """ Validar campo manual por string """
    if value == '' or value == None:
        return data_atual()
    return value

def validar_campo_manual(value):

    """ Valida informação manual do frete se não está vazio """
    if value == '' or value is None:
        return objDate(data_atual())
    return objDate(value)

def total_de_recebidos(acerto):

    """ Calcula o total de recebidos do Acerto """
    valores = []
    for i in acerto.recebidos:
        valores.append(returnMoneyString(i.valor))

    return sumMoneyList(valores)

def lista_cidades():

    """
    Retorna uma lista simples de todas as cidades em state.objects()
    """
    cidades = []
    estados = state.objects()

    for estado in estados:
        cidades = cidades + estado.cities

    return cidades

def verifica_tentativas_login(usuario):

    """ Validar o login e retorna para o VUE """
    novo_valor_tentativa = usuario.tentativas_de_login + 1
    if novo_valor_tentativa == 4:
        bloquear_usuario(usuario)
    else:
        usuario.update(tentativas_de_login=novo_valor_tentativa)
        usuario.save()

    if novo_valor_tentativa  == 3:
        return 'Seu usuário sera bloqueado no próximo erro.'

    if novo_valor_tentativa == 4:
        return 'Usuário bloqueado'

    if novo_valor_tentativa >= 1 & novo_valor_tentativa <= 2:
        return f'Tentativas de login restante: { 3 - novo_valor_tentativa }'

    usuario.update(tentativas_de_login=0)
    usuario.save()
    return None

def bloquear_usuario(user):

    """ Bloquear o usuário por falha de login """
    user.update(status='bloqueado', tentativas_de_login=0)
    user.save()

def all_to_upper(lista):

    """
    Recebe uma lista com itens em LowerCase
    Retorna a lista com todos itens em UpperCase
    """
    nova_lista = []
    for i in lista:
        nova_lista.append(i.upper())

    return nova_lista

def analisa_se_fornecedor_existe(fornecedor):

    """
    Analisa se o fornecedor informado durante a alteração
    do [Frete dos Acertos] existe.
    Se não ele cria com o nome informado e os padrões do DB
    """
    if fornecedor.upper() in all_to_upper(Fornecedores.objects().distinct('nome')):
        pass
    else:
        Fornecedores(nome=fornecedor.upper()).save()

    return fornecedor

def analisa_se_rota_existe(rota, origem, destino):

    """
    Analisa se a rota existe durante a alteração
    Se não existe, ele cria, informado rota, origem e destino atualizados.
    """
    if rota.upper() in all_to_upper(Rotas.objects().distinct('rota')):
        pass
    else:
        Rotas(rota=rota.upper(), origem=origem, destino=destino).save()

    return rota

def credito_cartao_pedagio(cartao, valor):

    """
    valida o valor informado e recalcula o saldo do cartao pedagio
    """
    novo_saldo = returnInt(valor) + returnInt(cartao.saldo)
    cartao.update(saldo=returnMoneyString(novo_saldo))
    return cartao

def debito_cartao_pedagio(cartao, valor):

    """
    valida o valor informado e recalcula o saldo do cartao pedagio
    """
    novo_saldo = returnInt(cartao.saldo) -  returnInt(valor)
    cartao.update(saldo=returnMoneyString(novo_saldo))
    return cartao

def ajusta_saldo_cartao_pedagio(cartao, valor, condicao):

    if condicao == 'RECARGA':
        novo_saldo = returnInt(cartao.saldo) - returnInt(valor)
    else:
        novo_saldo = returnInt(cartao.saldo) + returnInt(valor)
    cartao.update(saldo=returnMoney(novo_saldo))
    return cartao

def criar_media_exata_infracoes(infracao):

    """
    FUNÇÃO PARA CORRIGIR OS HORARIOS DAS INFRACÕES
    """
    configuracoes = Configuracoes.objects().first()
    limite_rodagem = configuracoes.limite_rodagem
    limite_jornada = configuracoes.limite_jornada
    jornada_minima = configuracoes.jornada_minima

    temp_diff = ""

    if infracao.sigla == "JE": #jornada excediga
        temp_diff = diferenca_hora(infracao.media, limite_jornada)
    elif infracao.sigla == "DI": #descanço irregular
        temp_diff = diferenca_hora("00:30", infracao.media)
    elif infracao.sigla == "RE": #rogagem excedida
        temp_diff = diferenca_hora(infracao.media, limite_rodagem)
    elif infracao.sigla == "AI": #alimentação irregular
        temp_diff = diferenca_hora("01:00", infracao.media)

    if temp_diff != "":
        infracao.update(diferenca_tempo=str(temp_diff))
        infracao.save()
        print (f'infracao {infracao.id}, dia: {infracao.data}, media: {infracao.media} - diff:{temp_diff}')

def diferenca_hora(maior, menor):

    try:
        maior = datetime.datetime.strptime(maior, '%H:%M').time()
        menor = datetime.datetime.strptime(menor, '%H:%M').time()
        maior = datetime.timedelta(hours=maior.hour, minutes=maior.minute)
        menor = datetime.timedelta(hours=menor.hour, minutes=menor.minute)
        diff = maior - menor

        return(diff)
    except:
        return("99:99")

def atualizar_troca_oleo_veiculo(id_veiculo, km_atual):
    """
    Atualiza as datas de troca de oleo do veiculo
    Função utilizada pelo arquivo api.py na rota nova_troca_oleo
    """
    proxima_troca = km_atual + 30000
    veiculo = Veiculos.objects.get(id=id_veiculo)
    veiculo.update(
            ultima_troca_oleo=int(km_atual),
            proxima_troca_oleo=int(proxima_troca)
            )
    veiculo.save()

def testa_vazio_obj(data):
    for value in data:
        if data[value]== "":
            return True
        else:
            return False

def reemb_motoristas(inicio = data_atual(), fim = data_atual()):
    acertos = Acertos.objects(
            data_retorno__gte=objDate(inicio),
            data_retorno__lte=objDate(fim),
            )

    valores = []
    for acerto in acertos:
        valores.append(acerto.total_cheques_reembolso)

    print(f'[total de reembolsos: {sumMoneyList(valores)}]')

def editar_os_interna(data):
    print('editando uma os interna')
    os = OsInterna.objects.get(id=data['_id']['$oid'])
    os.update(
            placa = data['placa'],
            carreta = data['carreta'],
            cavalo = data['cavalo'].upper(),
            motorista = data['motorista'],
            servicos = ajusta_servico(data['servicos']),
            mecanico = data['mecanico'].upper(),
            custo_total_servicos = custo_total_servicos(data['servicos']),
            custo_total_maodeobra = custo_total_maodeobra(data['maodeobra']),
            tipoManutencao = data['tipoManutencao'],
            maodeobra = ajusta_maodeobra(data['maodeobra']),
            descricaoDefeito = data['descricaoDefeito'],
            observacoes = data['observacoes'],
            dataAbertura = data['dataAbertura'],
            km = data['km'],
            ultimo_usuario = get_usuario(),
            ultima_hora_att = hora_atual(),
            custo = sumMoneyList([custo_total_servicos(data['servicos']), custo_total_maodeobra(data['maodeobra'])]),
            tipo_os = "interna",
            )
    os = atualizar_historico_os(os)
    os.save()
    return OsInterna.objects.get(id=os.id)

def editar_os_externa(data):
    print('editando uma os externa')
    os = OsExterna.objects.get(id=data['_id']['$oid'])
    os.update(
            placa = data['placa'],
            carreta = data['carreta'],
            cavalo = data['cavalo'].upper(),
            motorista = data['motorista'],
            servicos = ajusta_servico(data['servicos']),
            maodeobra = ajusta_maodeobra(data['maodeobra']),
            custo_total_servicos = custo_total_servicos(data['servicos']),
            custo_total_maodeobra = custo_total_maodeobra(data['maodeobra']),
            tipoManutencao = data['tipoManutencao'],
            fornecedor = data['fornecedor'].upper(),
            descricaoDefeito = data['descricaoDefeito'],
            observacoes = data['observacoes'],
            dataAbertura = data['dataAbertura'],
            km = data['km'],
            ultimo_usuario = get_usuario(),
            tipo_os = "externa",
            ultima_hora_att = hora_atual(),
            custo = sumMoneyList([custo_total_servicos(data['servicos']), custo_total_maodeobra(data['maodeobra'])])
            )
    os = atualizar_historico_os(os)
    os.save()
    return OsExterna.objects.get(id=os.id)

def custo_total_servicos(servicos):
    valores = []
    for servico in servicos:
        valores.append(servico['valor_total'])

    return sumMoneyList(valores)

def custo_total_maodeobra(maodeobra):
    valores = []
    for mao in maodeobra:
        valores.append(mao['valor'])

    return sumMoneyList(valores)

def ajusta_servico(data):
    for i in data:
        i['valor'] = i['valor'].replace(']','').replace('R$', 'R$ ')
        i['valor_total'] = calcula_custo_total_item(i['valor'], i['quantidade'])
        i['descricaoServico'] = i['descricaoServico'].upper()

    return data

def ajusta_maodeobra(data):
    for i in data:
        i['descricaoMaoDeObra'] = i['descricaoMaoDeObra'].upper()
        i['tipo_servico'] = i['tipo_servico'].upper()

    return data

def calcula_custo_total_item(valor, quantidade):
    valor = valor.replace(']','').replace('R$', 'R$ ')
    valor_total = returnMoneyString(returnInt(valor) * float(quantidade))

    return(valor_total)

def atualizar_historico_os(os):
    historico = {
            'usuario':get_usuario(),
            'data_string':data_atual(),
            'data':objDate(data_atual())
            }
    os.historico.append(historico)
    os.save()
    return os

def criar_nova_os(data):
    if data['tipo_os'] == 'interna':
        nova_os = OsInterna(
                numero = str(data['numero']),
                status = 'aberta',
                placa = data['placa'],
                carreta = data['carreta'],
                cavalo = data['cavalo'].upper(),
                motorista = data['motorista'],
                mecanico = data['mecanico'],
                km = data['km'],
                tipoManutencao = data['tipoManutencao'],
                descricaoDefeito = data['descricaoDefeito'].upper(),
                observacoes = data['observacoes'],
                dataAbertura = data['dataAbertura'],
                ultimo_usuario = get_usuario(),
                ultima_hora_att = hora_atual(),
                tipo_os = 'interna',
                )
        nova_os.save()
    else:
        nova_os = OsExterna(
                numero = str(data['numero']),
                status = 'aberta',
                placa = data['placa'],
                carreta = data['carreta'],
                cavalo = data['cavalo'].upper(),
                motorista = data['motorista'],
                fornecedor = data['fornecedor'],
                km = data['km'],
                tipoManutencao = data['tipoManutencao'],
                descricaoDefeito = data['descricaoDefeito'],
                observacoes = data['observacoes'],
                dataAbertura = data['dataAbertura'],
                ultimo_usuario = get_usuario(),
                ultima_hora_att = hora_atual(),
                tipo_os = 'externa',
                )
        nova_os.save()

    atualizar_ultimo_numero_os()
    return nova_os

def atualizar_ultimo_numero_os():
    config = Configuracoes.objects().first()
    novo_numero = config.ultimaos_interna + 1
    config.update(ultimaos_interna = novo_numero)
    config.save()

def teste_data_encerramento(data):
    retorno = data
    if data == "":
        retorno = data_atual()

    return retono

def finalizar_os_interna(data):
    os = OsInterna.objects.get(id=data['_id']['$oid'])
    os.update(
            placa = data['placa'],
            status = 'fechada',
            carreta = data['carreta'],
            cavalo = data['cavalo'],
            motorista = data['motorista'],
            mecanico = data['mecanico'].upper(),
            tipoManutencao = data['tipoManutencao'],
            descricaoDefeito = data['descricaoDefeito'],
            observacoes = data['observacoes'],
            dataAbertura = data['dataAbertura'],
            dataEncerramento = data['dataEncerramento'],
            ultimo_usuario = get_usuario(),
            ultima_hora_att = hora_atual(),
            )
    os.save()
    return OsInterna.objects.get(id=os.id)

def finalizar_os_externa(data):
    os = OsExterna.objects.get(id=data['_id']['$oid'])
    if os.status != "fechada":
        os.update(
                placa = data['placa'],
                status = 'fechada',
                carreta = data['carreta'],
                cavalo = data['cavalo'],
                fornecedor = data['fornecedor'],
                mecanico = data['mecanico'].upper(),
                tipoManutencao = data['tipoManutencao'],
                descricaoDefeito = data['descricaoDefeito'],
                observacoes = data['observacoes'],
                dataAbertura = data['dataAbertura'],
                dataEncerramento = data['dataEncerramento'],
                ultimo_usuario = get_usuario(),
                ultima_hora_att = hora_atual(),
                )
        os.save()

        atualiza_dados_veiculo_os(os)
        atualiza_despesas_veiculo(os)
        logger('OS Interna [{}] encerrada'.format(os.numero))
    return OsExterna.objects.get(id=os.id)

def atualiza_dados_veiculo_os(os):
    veiculo = Veiculos.objects.get(placa=os.placa)
    veiculo.osHistorico.append(os.numero)

    veiculo.update(
            status="DISPONIVEL",
            )

    veiculo.save()

def atualizar_valores_os(os):
    valores_servicos = []
    for servico in os.servicos:
        valores_servicos.append(servico['valor_total'])

    valores_mao = []
    for mao in os.maodeobra:
        valores_mao.append(mao['valor'])

    os.custo_total_servicos = sumMoneyList(valores_servicos)
    os.custo_total_maodeobra = sumMoneyList(valores_mao)

    os.custo = sumMoneyList([os.custo_total_servicos,os.custo_total_maodeobra])

    os.update(custo=sumMoneyList([os.custo_total_maodeobra,os.custo_total_servicos]))
    return os.save()

def altera_quantidade_estoque(item, quantidade, data):
    item = Itens.objects.get(codigo=item)
    item.qtEstoque = item.qtEstoque - quantidade

    item.historicoSaida.append(
            {
            'data':data['data'],
            'dataObj':objDate(data_atual()),
            'data_string':data_atual(),
            'usuario':get_usuario(),
            'os':data['numero'],
            'descricao':'Item usado na OS',
            'quantidade':quantidade,
            }
            )
    item.save()

def recoloca_quantidade_estoque(item, quantidade, data):
    item = Itens.objects.get(codigo=item)
    item.qtEstoque = item.qtEstoque + quantidade
    item.historicoEntrada.append(
            {
            'data':data['data'],
            'dataObj':objDate(data_atual()),
            'data_string':data_atual(),
            'usuario':get_usuario(),
            'os':data['numero'],
            'descricao':'Item removido da OS',
            'quantidade':quantidade,
            }
            )
    item.save()

def importar_extrato(banco, data):
    if banco.clipper_filename == None:
        clipper_filename = "LAN"+banco.codigoOffice+".DBF"
        banco.update(clipper_filename=clipper_filename)
        banco.save()

    if copiar_arquivo_banco(banco.clipper_filename):
        lancamentos_bancos = BancosLancamentos.objects(data__gte=objDate(data),banco=banco.banco)
        deletar_registros = deletar_registros_banco(lancamentos_bancos)
        registros = abrir_arquivo_dbf(banco.clipper_filename, data)
        criar_registros = criar_registros_banco(registros, banco, data)

        if criar_registros:
            return True

    return False

def abrir_arquivo_dbf(filename: str, data):
    path_dbfs_banco = Configuracoes.objects().first().path_dbfs_banco

    registros = []
    data = objDate(data)
    for record in DBF(path_dbfs_banco+filename, encoding='cp850'):
        if objDate(dataDBF(record['DATA'])) >= data:
            registros.append(record)

    return  registros

def criar_registros_banco(registros, banco, date):
    """
    IMPORTA REGISTROS DO OFFICE PARA O MONGO
    """
    for data in registros:
        novo_lancamento_banco = BancosLancamentos(
                banco = banco.banco,
                numero = str(data['NUMERO']),
                operacao = str(data['OPERACAO']),
                codigo = str(data['CODIGO']),
                valor = returnMoneyString(data['VALOR']),
                especie = str(data['ESPECIE']),
                valor_int = returnInt(returnMoneyString(data['VALOR'])),
                valor_float = float_money(returnMoneyString(data['VALOR'])),
                historico = data['HISTORICO'],
                data_string = dataDBF(data['DATA']),
                data = objDate(dataDBF(data['DATA'])),
                data_pre = objDate(dataDBF(data['DTPRE'])),
                data_pre_string = dataDBF(data['DTPRE']),
                ipmf = str(data['IPMF']),
                observacoes = data['OBS'],
                debito_credito = data['DC'],
                data_baixa = objDate(dataDBF(data['DATA_BAIXA'])),
                tipo_baixa = data['TIPO_BAIXA'],
                caixa_conta = data['CX_CONTA'],
                caixa_controle = str(data['CX_CONTROL']),
                caixa_observacao = data['CX_OBS'],
                nominal = data['NOMINAL'],
                extrato = str(data['EXTRATO']),
            )
        novo_lancamento_banco.save()

    return True

def copiar_arquivo_banco(filename: str):
    try:
        delete = os.system(f"cd /home/cadomar/syscadomar/cadomar/dbf_files/bancos/{filename}")
        copia = os.system(f"sshpass -p 'tr3m3r3' scp root@192.168.0.4:/srv/dev-disk-by-label-dados/Sistemas/JEFERSON/CHEQUES/LANCAM/{filename} /home/cadomar/syscadomar/cadomar/dbf_files/bancos/{filename}")
        return True
    except:
        return False

class AjutesAstoque():
    def ajusta_data_lancamento_saidas(self):
        saidas  = SaidasEstoque.objects()
        for saida in saidas:
            dia = ajusta_zero_data(saida.dia)
            mes = ajusta_zero_data(saida.mes)

            data_saida = f"{dia}/{mes}/{saida.ano}"
            if saida.dataLancamento == None:
                saida.update(dataLancamento=objDate(data_saida))
                saida.save()

def valida_custo_item_despesa(inicio,fim):
    despesas = Despesas.objects(
            dataLancamento__gte=obj_date(inicio),
            dataLancamento__lte=obj_date(fim),
            itemEstoque__contains="|",
            )

    for despesa in despesas:
        item = despesa.itemEstoque.split('|')[0].replace(' ','')
        if despesa.quantidade > 1:
            item_temp = Itens.objects.get(codigo=item)
            novo_valor = despesa.quantidade * returnInt(item_temp.custoMedio)
            despesa.update(valor=returnMoneyString(novo_valor))
            despesa.save()

def ajusta_zero_data(valor):
    if valor == None:
        valor = '01'

    if int(valor) < 10:
        return f"0{valor}"

    return valor

def Convert(a):
    it = iter(a)
    res_dct = dict(zip(it, it))
    return res_dct

def une_ponto_jornada(motorista):
    jornadas = Jornadas.objects(codigo=motorista)
    for jornada in jornadas:
        ponto = Ponto.objects.get(codigo=motorista, data=jornada.data)
        ponto_dict = [
                'viagem',ponto.viagem,
                'data',ponto.data,
                'ij_tempo',ponto.ij_tempo,
                'dr_tempo',ponto.dr_tempo,
                'ia_tempo',ponto.ia_tempo,
                'ha_tempo',ponto.ha_tempo,
                'id_tempo',ponto.id_tempo,
                'te_tempo',ponto.te_tempo,
                ]
        # a = Convert(ponto_dict)
        jornada.save()

def calcula_hora_extra(resultados, motorista):
    if int(resultados['ij'].split(':')[0]) >= 8:
        hora50 = calcular_tempo('08:00', resultados['ij'])
        hora50 = "02:00" if hora50 > "02:00" else hora50
    else:
        hora50 = '00:00'

    if int(resultados['ij'].split(':')[0]) >= 10:
        hora100 = calcular_tempo('10:00', resultados['ij'])
    else:
        hora100 = '00:00'

    valor_dia = horaVSvalor('08:00', motorista.valor_hora,0)
    valor_hora_50 = horaVSvalor(hora50, motorista.valor_hora,0.5)
    valor_hora_100 = horaVSvalor(hora100, motorista.valor_hora,1.0)

    valores = {
            'valor_hora_50':valor_hora_50,
            'valor_hora_100':valor_hora_100,
            'valor_dia':valor_dia,
            'horas_extras_50':hora50,
            'horas_extras_100':hora100
            }

    return valores

def atualiza_jornada_com_he():
    motoristas = Motoristas.objects().distinct('codigo')

    for codigo_motorista in motoristas:
        jornadas = Jornadas.objects(codigo=codigo_motorista)
        n_jor = jornadas.count()
        print(f'{codigo_motorista} tem {n_jor} jornadas para processamento')

        counter = 0
        for jornada in jornadas:
            counter += 1
            print(f'{counter} de {n_jor}')
            inclusao_de_ponto(jornada)

def atualizar_valores_jornadas():
    jornadas = Jornadas.objects(float_valor_dia=None)
    count_jornadas = jornadas.count()
    counter = 0
    for jornada in jornadas:
        counter += 1
        jornada.update(
            float_valor_he_50 = float_money(jornada.valor_he_50),
            float_valor_he_100 = float_money(jornada.valor_he_100),
            float_valor_dia = float_money(jornada.valor_dia)
            )
        jornada.save()
        print(f'{counter} de {count_jornadas}')

def atualizar_data_jornadas(motorista):
    jornadas = Jornadas.objects(codigo=motorista)

    for jornada in jornadas:
        jornada.update(obj_data=obj_date(ajuste_data_jornada(jornada.data)))
        jornada.save()

def ajuste_data_jornada(data):
    dia = data.split('/')[0]
    mes = data.split('/')[1]
    ano = data.split('/')[2]

    if len(ano) == 2:
        ano = "20"+ano

    if len(ano) == 3:
        ano = str(datetime.datetime.now().year)

    return f'{dia}/{mes}/{ano}'

def limpar_relatorio_jornadas(jornadas):
    relatorio = []
    for jornada in jornadas:
        dict_temp = {
                "dia":ajuste_data_jornada(jornada.data),
                "viagem":f'{jornada.viagem_1}.{jornada.viagem_2}.{jornada.viagem_3}',
                "ia_tempo":jornada.ia_tempo,
                "id_tempo":jornada.id_tempo,
                "ij_tempo":jornada.ij_tempo,
                "te_tempo":jornada.te_tempo,
                "hora_normal":jornada.valor_dia,
                "tempo_he_50":jornada.horas_extras_50,
                "tempo_he_100":jornada.horas_extras_100,
                "he_50":jornada.valor_he_50,
                "he_100":jornada.valor_he_100,
                }
        relatorio.append(dict_temp)
    return relatorio

def limpar_relatorio_jornadas_motorista(jornadas):

    valor_dia = returnMoneyString(jornadas.sum('float_valor_dia'))
    valor_50 =  returnMoneyString(jornadas.sum('float_valor_he_50'))
    valor_100 = returnMoneyString(jornadas.sum('float_valor_he_100'))

    l_ia = []
    l_id = []
    l_ij = []
    l_te = []
    l_h50 = []
    l_h100 = []

    for jor in jornadas:
        # print(jor.data, jor.nome, jor.ij_tempo)
        ia = datetime.datetime.strptime(corrige_hora(jor.ia_tempo),"%H:%M:%S")
        id = datetime.datetime.strptime(corrige_hora(jor.id_tempo),"%H:%M:%S")
        ij = datetime.datetime.strptime(corrige_hora(jor.ij_tempo),"%H:%M:%S")
        te = datetime.datetime.strptime(corrige_hora(jor.te_tempo),"%H:%M:%S")
        he50 = datetime.datetime.strptime(corrige_hora(jor.horas_extras_50),"%H:%M:%S")
        he100 = datetime.datetime.strptime(corrige_hora(jor.horas_extras_100),"%H:%M:%S")

        delta_ia = datetime.timedelta(hours = ia.hour, minutes=ia.minute, seconds=ia.second)
        delta_id = datetime.timedelta(hours = id.hour, minutes=id.minute, seconds=id.second)
        delta_ij = datetime.timedelta(hours = ij.hour, minutes=ij.minute, seconds=ij.second)
        delta_te = datetime.timedelta(hours = te.hour, minutes=te.minute, seconds=te.second)
        delta_he_50 = datetime.timedelta(hours = he50.hour, minutes=he50.minute, seconds=he50.second)
        delta_he_100 = datetime.timedelta(hours = he100.hour, minutes=he100.minute, seconds=he100.second)

        l_ia.append(delta_ia)
        l_id.append(delta_id)
        l_ij.append(delta_ij)
        l_te.append(delta_te)
        l_h50.append(delta_he_50)
        l_h100.append(delta_he_100)

    relatorio = {
            "motorista":jornadas[0].nome,
            "valor_dia":valor_dia,
            "he_50":valor_50,
            "he_100":valor_100,
            "total_ia":str(functools.reduce(operator.add, l_ia)),
            "total_id":str(functools.reduce(operator.add, l_id)),
            "total_ij":str(functools.reduce(operator.add, l_ij)),
            "total_te":str(functools.reduce(operator.add, l_te)),
            "total_he_50":str(functools.reduce(operator.add, l_h50)),
            "total_he_100":str(functools.reduce(operator.add, l_h100)),
            }

    return relatorio

def corrige_hora(hora):
    if hora == "":
        return "00:00:00"
    elif hora == "24:00":
        return "23:59:00"
    else:
        if int(hora.split(':')[0]) > 24:
            return "00:00:00"
        else:
            hora = hora.split(':')
            if hora[1] == "60":
                nova_hora = f'{hora[0]}:59:59'
                return nova_hora
            else:
                return f'{hora[0]}:{hora[1]}:00'

def ajuste_de_varias_coisas():
    print("estou ajustando")

def criar_total(diarias:list) -> str:
    valores = []

    for diaria in diarias:
        valores.append(diaria.total_diarias)

    return sumMoneyList(valores)

def ajusta_valores_hora_extra(data:str) -> None:
    motoristas = Motoristas.objects()

    for motorista in motoristas:
        print(f"Ajustando as jornadas do motorista {motorista.nome}")
        jornadas = Jornadas.objects(codigo=motorista.codigo,horas_extras_50__ne=None,obj_data__gte=obj_date(data))
        for jornada in jornadas:
            print(f"Ajustando a viagem jornada - {jornada.id}")
            if jornada.horas_extras_50 >= '02:00':
                valor = horaVSvalor("02:00",motorista.valor_hora,0.5)
                jornada.update(
                    horas_extras_50="02:00",
                    valor_he_50=valor,
                    float_valor_he_50=float_money(valor)
                )
            else:
                jornada.update(
                    valor_he_50=horaVSvalor(jornada.horas_extras_50,motorista.valor_hora,0.5)
                )

            jornada.save()

formatos= [
     '%Y/%m/%dT%H:%M:%S+0000',
     '%Y-%m-%dT%H:%M:%S+0000',
     '%Y-%m-%d %H:%M:%S+0000',
     '%Y/%m/%d %H:%M:%S',
     '%Y-%m-%dT%H:%M:%S',
     '%Y-%m-%dT%H:%M:%S',
     '%Y/%m/%dT%H:%M:%S',
     '%d/%m/%Y %H:%M:%S',
     '%d/%m/%Y',
]

def string_to_time(date:str=''):
    """Tratamento de data para salvar no ELASTIC"""
    date = str(date)
    formatos.append('')
    if date:
        return  dateparser.parse(date, date_formats=formatos).strftime("%H:%M")
    return date

def tratamento_data_sql(date: str, modificador: int = None) -> str:
    """Tratamento de data para salvar no SQL"""
    date = str(date)
    if date:
        if modificador:
            return altera_data_com_modificador(date,modificador)
        return  dateparser.parse(date, date_formats=formatos).strftime("%Y-%m-%d %H:%M:%S")
    return date

def tratamento_data_since(date:str ='') -> str:
    """ Tratamento de data para usar na consulta KNEWIN."""
    formatos.append('')
    date = str(date)
    if date:
        return  dateparser.parse(date, date_formats=formatos).strftime("%Y-%m-%dT%H:%M:%S")
    return date

def altera_data_com_modificador(date: str, modificador:int) -> str:
    date = dateparser.parse(date, date_formats=formatos).strftime("%Y-%m-%d %H:%M:%S")
    date = datetime.datetime.strptime(date, "%Y-%m-%d %H:%M:%S") + datetime.timedelta(days=modificador)
    return  dateparser.parse(str(date), date_formats=formatos).strftime("%Y-%m-%dT%H:%M:%S")

def retorna_apenas_data(data:str) -> str:
    data = data.strftime("%Y-%m-%d")
    return datetime.datetime.strptime(data, "%Y-%m-%d")

def ajusta_placa_viagens(motorista:str, placa, data_inicial, data_final) -> None:
    jornadas = Jornadas.objects(
            codigo=motorista,
            nova_data_log__gte=obj_date(data_inicial),
            nova_data_log__lte=obj_date(data_final)
            )

    for jornada in jornadas:
        print(f"MOTORISTA:{jornada.codigo}  DATA  {jornada.data} - {jornada.viagem_1}.{jornada.viagem_2}.{jornada.viagem_3}")
        jornada.update(veiculo=placa)
        jornada.save()
        print("Jornada alterada")

def recria_despesas_para_os(os:int = None):
    externas = OsExterna.objects(maodeobra__ne=[])

    for os in externas:
        analisa_despesas(os.maodeobra)

def primeiro_dia_mes() -> str:
    data_split = data_atual().split('/')
    data_split[0] = "01"
    return ('/'.join(data_split))

def ajusta_data_despesas():
    despesas = Despesas.objects(data=None)
    despesas2 = Despesas.objects(dia=None)

    for despesa in despesas:
        nova_data = return_string_date(despesa.dataLancamento)
        despesa.update(
                data=nova_data,
                dia = nova_data.split('/')[0],
                mes = nova_data.split('/')[1],
                ano = nova_data.split('/')[2]
                )
        despesa.save()

    for despesa in despesas2:
        print(f"Ajustando despesa {despesa.id}")
        nova_data = return_string_date(despesa.dataLancamento)
        despesa.update(
                dia = nova_data.split('/')[0],
                mes = nova_data.split('/')[1],
                ano = nova_data.split('/')[2]
                )
        despesa.save()

def completar_ano_data(data):
    dia = data.split('/')[0]
    mes = data.split('/')[1]
    ano = data.split('/')[2]

    return f"{dia}/{mes}/20{ano}"

def completa_mes(m):
    if len(m) == 1:
        return f"0{m}"
    else:
        return m

# def ajustar_mes_jornadas(v,m):
#     v = v.split('.')
#     m = completa_mes(m)
#
#     print(v)
#
#     jornadas = Jornadas.objects(viagem_1=v[0],viagem_2=v[1],viagem_3=v[2])
#
#     for j in jornadas:
#         j.update(
#             month=m,
#             data = data.split('/')
#         )