Exemple #1
0
 def __init__(self, empresa, mes, anio, esnomina=True, esfiniquito=False, esnominapextra=False):
     self.empresa = empresa
     self.dia = ultimodiames(mes, anio)
     self.mes = mes
     self.anio = anio
     self.nomina = SqlNominas(0)
     self.NomDev = Nomina_Devengo
     self.num_nominas = Contrato(0).contratos_activos_mes(self.empresa, self.anio, self.mes)
     self.fecha = str(self.anio) + "-" + str(self.mes) + "-" + str(self.dia)
     locale.setlocale(locale.LC_ALL, 'es_ES.UTF-8')
     self.estemes = time.strftime("%B", time.strptime(str(self.mes) + ',' + str(self.anio), '%m,%Y'))
     self.esnomina = esnomina
     self.esfiniquito = esfiniquito
     self.esnominapextra = esnominapextra
     self.borrarnominas = NomBorrar(self.empresa, self.mes, self.anio, 0, self.esnomina, self.esfiniquito,
                                    self.esnominapextra)
     print "Empieza el calculo ..."
Exemple #2
0
 def __init__(self, idit = 0):
     self.id = idit
     self.alta_dia = self.dato_it('dayofmonth(fecha_alta)')
     self.alta_mes = self.dato_it('month(fecha_alta)')
     self.alta_anio = self.dato_it('year(fecha_alta)')
     self.baja_dia = self.dato_it('dayofmonth(fecha_baja)')
     self.baja_mes = self.dato_it('month(fecha_baja)')
     self.baja_anio = self.dato_it('year(fecha_baja)')
     self.baja_fecha = datetime.date(self.baja_anio, self.baja_mes, self.baja_dia)
     self.basecot_mes_anterior = self.dato_it('basecot_mesant')
     self.contrato_id = self.dato_it('idemp_contrato')
     self.dias_cotizados_mes_anterior = self.dato_it('diascot_mesant')
     self.es_cont_comun = si_no(self.dato_it('convert(es_baja_contcomun, unsigned)'))
     self.es_enfermedad_prof = si_no(self.dato_it('convert(es_baja_enfprof,unsigned)'))
     self.basecot_diaria_it = round(self.basecot_mes_anterior / self.dias_cotizados_mes_anterior, 2)
     try:
         self.alta_fecha = datetime.date(self.alta_anio, self.alta_mes, self.alta_dia)
     except:
         self.alta_fecha = None
     self.contrato = Contrato(self.contrato_id)
     self.it_id = self.dato_it('idtb_it')
Exemple #3
0
 def __init__(self,
              idempresa,
              mes,
              anio,
              idcontrato=0,
              esnomina=True,
              esfiniquito=False,
              esnominapextra=False):
     '''
     Constructor
     '''
     self.empresa_id = idempresa
     self.esnomina = esnomina
     self.esnominapextra = esnominapextra
     self.esfiniquito = esfiniquito
     self.mes = mes
     self.anio = anio
     self.contrato_id = idcontrato
     try:
         self.contrato = Contrato(self.contrato_id)
     except:
         pass
 def dias_entre_fechas(self):
     contrato = Contrato()
     dia_final = self.hasta(anio, mes, dia)
Exemple #5
0
    def __init__(self, nomina=0):
        self.id = nomina
        self.base_ppextra = self.dato_nomina('base_ppextra')
        self.base_irpf = self.dato_nomina('base_irpf')
        self.base_cc = self.dato_nomina('base_cc')
        self.cif = self.dato_nomina("cif")
        self.contrato_id = self.dato_nomina('idemp_contratos')
        self.contrato = Contrato(self.contrato_id)
        try:
            self.dirtrabajador = self.contrato.trabajador.direccion_completa
            self.cptrabajador = self.contrato.trabajador.cod_postal
            self.pobtrabajador = poblacion(self.cptrabajador)
            self.provtrabajador = provincia(self.cptrabajador)
            self.motivoextincion = self.contrato.motivoextincion
        except:
            pass
        self.cta_cot_id = self.dato_nomina('idcta_cot')
        try:
            self.cta_cot = Cod_cotizacion(self.cta_cot_id)
            self.dirempresa = self.cta_cot.centro_trabajo.dircompleta
            self.cpempresa = self.cta_cot.centro_trabajo.dir_codpostal
            self.pobempresa = poblacion(self.cpempresa)
            self.provempresa = provincia(self.cpempresa)

        except:
            print 'No se activa la cta_cot'
            self.cta_cot = 0
        self.descripcion = self.dato_nomina('descripcion')
        self.empresa_id = self.dato_nomina('idempresa')
        self.es_finiquito = si_no(self.dato_nomina('es_finiquito'))
        self.es_nominapextra = si_no(self.dato_nomina('es_nominapextra'))
        self.epigrafe_id = self.dato_nomina('idtb_epigrafe')
        self.fecha = self.dato_nomina('fecha')
        self.fecha_dia = self.dato_nomina('dayofmonth(fecha)')
        self.grupo_cotizacion_id = self.dato_nomina('idgrupos_cotizacion')
        self.imp_pextra = self.dato_nomina('imp_pextra')
        self.imp_remumes = self.dato_nomina('imp_remumes')
        self.nif = self.dato_nomina('dni')
        self.naf = self.dato_nomina('naf')
        self.nombre_trabajador = self.dato_nomina('nombre')
        self.nombreempresa = SqlEmpresa(self.empresa_id).razon_social
        self.periodo = self.dato_nomina('periodo')
        self.puesto = self.dato_nomina('categoria')
        self.fecha_anio = self.dato_nomina('year(fecha)')
        self.fecha_mes = self.dato_nomina('month(fecha)')
        self.dia_nomina = self.dato_nomina('dayofmonth(fecha)')
        try:
            self.fecha_datetime = datetime.date(self.fecha_anio,
                                                self.fecha_mes,
                                                self.dia_nomina)
            locale.setlocale(locale.LC_ALL, 'es_ES.UTF-8')
            self.fecha_formlargo = self.fecha_datetime.strftime(
                '%d de %B de %Y')
            self.periodos = self.contrato.periodo_nomina(
                self.fecha_anio, self.fecha_mes)
        except ValueError:
            print(
                'No hay nomina activa, no se crea fecha_datetime y tampoco hay periodo de tiempo'
            )
            self.fecha_datetime = 0

        self.numero_nominas_mes = self.contrato.contratos_activos_mes(
            self.empresa_id, self.fecha_anio, self.fecha_mes)
        try:
            self.cabecera = Cabecera(self.empresa_id, self.fecha_mes,
                                     self.fecha_anio,
                                     self.contrato.trabajador.id)
        except AttributeError:
            print(
                'Si no hay nómina, no hay contrato y tampoco trabajador. Se pierde la cabecera'
            )
        self.total_devengos = self.dato_nomina('imp_totdev')
        self.total_deducciones = self.dato_nomina('tot_deducir')
        self.liquido = self.dato_nomina('liquido')
        self.liquido_letras = to_word(self.liquido)
Exemple #6
0
    def __init__(self, nomina):
        self.id = nomina
        self.bases = Bases(self.id)
        self.contrato = Contrato(self.bases.nomina.contrato_id)
        self.sql = ("Select "
                    "empresa, trabajador "
                    "From "
                    "tb_tiposcot A "
                    "inner join "
                    "tb_tiposcot_ejercicio B "
                    "on A.idtb_tiposcot = B.idtb_tipocot "
                    "Where "
                    "B.ejercicio = %s ")
        if self.contrato.contrato.es_indefinido:
            self.sql += "and A.es_dura_indefinida "
        elif self.contrato.contrato.es_temporal:
            self.sql += "and A.es_dura_determinada "
        elif self.contrato.contrato.es_tiempo_completo:
            self.sql += "and A.es_tpo_completo "
        elif self.contrato.contrato.es_tiempo_parcial:
            self.sql += "and A.es_tpo_parcial "
        self.tipo_ccomun_emp = self.tipos_cont_comun()[0]
        self.tipo_ccomun_trab = self.tipos_cont_comun()[1]
        self.tipo_desempleo_emp = self.tipos_desempleo()[0]
        self.tipo_desempleo_trab = self.tipos_desempleo()[1]
        self.tipo_fp_emp = self.tipos_formacion_prof()[0]
        self.tipo_fp_trab = self.tipos_formacion_prof()[1]
        self.tipo_fogasa_emp = self.tipos_fogasa()[0]
        self.tipo_fogasa_trab = self.tipos_fogasa()[1]

        self.base_cotizacion = self.bases.base_segsocial
        self.cont_comun_empresa = round(
            self.tipo_ccomun_emp * self.base_cotizacion / 100, 2)
        self.cont_comun_trabajador = round(
            self.tipo_ccomun_trab * self.base_cotizacion / 100, 2)
        self.desempleo_empresa = round(
            self.tipo_desempleo_emp * self.base_cotizacion / 100, 2)
        self.desempleo_trabajador = round(
            self.tipo_desempleo_trab * self.base_cotizacion / 100, 2)
        self.formacion_prof_emp = round(
            self.tipo_fp_emp * self.base_cotizacion / 100, 2)
        self.formacion_prof_trab = round(
            self.tipo_fp_trab * self.base_cotizacion / 100, 2)
        self.fogasa_emp = round(
            self.tipo_fogasa_emp * self.base_cotizacion / 100, 2)
        self.fogasa_trabajador = round(
            self.tipo_fogasa_trab * self.base_cotizacion / 100, 2)
        self.segsocial_empresa = (self.cont_comun_empresa +
                                  self.desempleo_empresa +
                                  self.formacion_prof_emp + self.fogasa_emp)
        self.total_aportacion = (
            self.cont_comun_trabajador + self.desempleo_trabajador +
            self.formacion_prof_trab)  #+ self.horasextras())
        #self.total_deduccion = (self.total_aportacion + self.irpf_dineraria() +
        #                        self.irpf_especie() + self.anticipos() +
        #                        self.valor_especie() + self.otras_deducciones())
        self.sql = ("Select "
                    "empresa, trabajador "
                    "From "
                    "tb_tiposcot A "
                    "inner join "
                    "tb_tiposcot_ejercicio B "
                    "on A.idtb_tiposcot = B.idtb_tipocot "
                    "Where "
                    "B.ejercicio = %s ")
        if self.contrato.contrato.es_indefinido:
            self.sql += "and A.es_dura_indefinida "
        elif self.contrato.contrato.es_temporal:
            self.sql += "and A.es_dura_determinada "
        elif self.contrato.contrato.es_tiempo_completo:
            self.sql += "and A.es_tpo_completo "
        elif self.contrato.contrato.es_tiempo_parcial:
            self.sql += "and A.es_tpo_parcial "
Exemple #7
0
    def nominas_empresa(self):
        """
        1. Insertamos las cabeceras de las nominas sin calculos
           basados en los contratos de la empresa ACTUALIZADOS
        """
        print "insertamos los nuevos registros ...."
        f = self.cabecera.nomina(self.es_nomina, self.es_finiquito,
                                 self.es_nominapextra)
        sql = "Select max(idnomina) as maxid from nominas"
        j = select_sql(sql)[0]

        if not j:
            j = 0
        for filas in f:
            j += 1  # numero de nomina o idnomina
            print "Insertamos las cabeceras de la nomina ************************", j
            sql = ('INSERT INTO nominas '
                   '(`idnomina`, `idempresa`, `idemp_contratos`, '
                   '`idgrupos_cotizacion`, `idtb_epigrafe`, `antig`, '
                   '`descripcion`, `liquido`, `naf`, `tarifa`, `epigrafe`, '
                   '`matricula`, `nombre`, `categoria`, `dni`, `empresa`, '
                   '`dir`, `cta_cot`, `cif`, fecha, idcta_cot, es_finiquito) '
                   'VALUES '
                   '(%s ,%s, %s, %s, %s, %s, %s, %s, %s, %s, '
                   '%s ,%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)')
            select_sql(
                (sql,
                 (j, filas[0], filas[1], filas[2], filas[3], str(filas[4]),
                  ("Nominas de " + self.estemes + " de " + str(self.anio)),
                  filas[5], filas[6], filas[7], filas[8], filas[9], filas[10],
                  filas[11], filas[12], filas[13], filas[14], filas[15],
                  filas[16], self.fecha, filas[18], self.es_finiquito)))
            # Comprobamos si el contrato es de jornada parcial
            self.SqlNom(j)
            z = self.SqlNom.nomina_a_tiempo_parcial()

            # ## Insertamos los devengos de nominas
            print "Insertamos los devengos de nominas ***************************", j, self.SqlNom.contrato.trabajador.nombre
            """
        2. Insertamos los devengos de las nominas a las nóminas a calcular
            """
            sql = ('SELECT '
                   'idemp_devengo, orden, concepto, importe, irpf, cont_com, '
                   'desempleo, fp, fgs, it, ims, ppextra, mensual, diario, '
                   'horas, idemp_pextra, dias_efectivos, dias_naturales, '
                   'esdevengo, esirpf, esdieta, esespecie, esporcentaje, '
                   'esmanual, coef_pextra, fraccionhoras, idform_concepto, '
                   'esvacaciones, pagavacaciones, es_complemento_it_cc, '
                   'es_complemento_it_ef, es_indemnizacion '
                   'FROM '
                   'emp_devengos '
                   'WHERE '
                   'idemp_contrato = %s ')
            sql1 = sql + ('and '
                          '(esdevengo '
                          'and not es_indemnizacion '
                          'and not esvacaciones '
                          'and not es_complemento_it_cc '
                          'and not es_complemento_it_ef '
                          'and (not idemp_pextra or idemp_pextra is null)) ')

            sql1 += 'ORDER by idemp_contrato, orden '
            h = select_sql((sql1, (filas[1])), 1)
            k = select_sql("Select max(idnomina_devengo) + 1 "
                           "from nomina_devengos")[0]
            orden = 0
            sql2 = ("INSERT INTO nomina_devengos "
                    "(`idnomina_devengo`, `idnomina`, `idemp_devengo`, "
                    "`orden`, `concepto`, `importe`, `irpf`, `cont_com`, "
                    "`desempleo`,`fp`, `fgs`, `it`, `ims`, `ppextra`, "
                    "`mensual`, `diario`, `horas`, `idemp_pextra`, "
                    "`dias_efectivos`, `dias_naturales`, `esdevengo`, "
                    "esirpf, esdieta, esespecie, esporcentaje, esmanual, "
                    "coef_pextra, fraccionhoras, idform_concepto, "
                    "esvacaciones, pagavacaciones, es_complemento_it_cc, "
                    "es_complemento_it_ef, es_indemnizacion) "
                    "VALUES "
                    "(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, "
                    "%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, "
                    "%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, "
                    "%s, %s, %s, %s)")
            print "*********************** Devengos "
            if self.es_nomina:
                for col in h:
                    print '    ', col[2], col[3]
                    orden += 1
                    if not k:
                        k = 1
                    else:
                        k += 1

                    campos = (k, j, col[0], orden, col[2], col[3], col[4],
                              col[5], col[6], col[7], col[8], col[9], col[10],
                              col[11], col[12], col[13], z, col[15], col[16],
                              col[17], col[18], col[19], col[20], col[21],
                              col[22], col[23], col[24], col[25], col[26],
                              col[27], col[28], col[29], col[30], col[31])
                    select_sql((sql2, campos))
            """
        3. Insertamos las pagas extras si están prorrateadas de las nóminas a calcular o es finiquito o es nomina
            """
            contrato = Contrato(filas[1])
            if (contrato.con_prorrata_pextra
                    or (not contrato.con_prorrata_pextra and self.es_finiquito)
                    or self.es_nominapextra):
                print "*********************** Prorrateo pagas extras / Finiquito "
                sql1 = sql + ("and "
                              "(esdevengo "
                              "and not es_indemnizacion "
                              "and not esvacaciones "
                              "and not es_complemento_it_cc "
                              "and not es_complemento_it_ef "
                              "and  idemp_pextra) "
                              "ORDER by "
                              "orden")
                h = select_sql((sql1, (filas[1])), 1)
                k = select_sql("Select max(idnomina_devengo) "
                               "from nomina_devengos")[0]
                for col in h:
                    print '    ', col[2], col[3]
                    orden += 1
                    if not k:
                        k = 1
                    else:
                        k += 1
                    campos = (k, j, col[0], orden, col[2], col[3], col[4],
                              col[5], col[6], col[7], col[8], col[9], col[10],
                              col[11], col[12], col[13], z, col[15], col[16],
                              col[17], col[18], col[19], col[20], col[21],
                              col[22], col[23], col[24], col[25], col[26],
                              col[27], col[28], col[29], col[30], col[31])
                    select_sql((sql2, campos))
            """
        4. Insertamos los devengos si hay baja por enfermedad
            """
            # Comprobamos si hay baja por IT
            base = Bases(j)
            print "*********************** Bases"
            try:
                base.it_nomina.it_dias_mes
                print "*********************** IT "
                sql1 = sql + ("and es_complemento_it_cc "
                              "ORDER by "
                              "idemp_contrato, orden")
                h = select_sql((sql1, (filas[1])), 1)
                k = select_sql("Select max(idnomina_devengo) "
                               "from nomina_devengos")[0]
                for col in h:
                    print '    ', col[2], col[3]
                    orden += 1
                    if not k:
                        k = 1
                    else:
                        k += 1
                    campos = (k, j, col[0], orden, col[2], col[3], col[4],
                              col[5], col[6], col[7], col[8], col[9], col[10],
                              col[11], col[12], col[13], z, col[15], col[16],
                              col[17], col[18], col[19], col[20], col[21],
                              col[22], col[23], col[24], col[25], col[26],
                              col[27], col[28], col[29], col[30], col[31])
                    select_sql((sql2, campos))
            except:
                pass
            '''
            5. Insertamos la indemnización si es un finiquito
            '''
            print "*********************** Indemnizacion Finiquito"
            if self.es_finiquito:
                sql1 = sql + (" and (es_indemnizacion "
                              " or esvacaciones) "
                              " ORDER by "
                              " idemp_contrato, orden ")
                h = select_sql((sql1, (filas[1])), 1)
                k = select_sql("Select max(idnomina_devengo) "
                               "from nomina_devengos")[0]
                for col in h:
                    print '    ', col[2], col[3]
                    orden += 1
                    if not k:
                        k = 1
                    else:
                        k += 1
                    campos = (k, j, col[0], orden, col[2], col[3], col[4],
                              col[5], col[6], col[7], col[8], col[9], col[10],
                              col[11], col[12], col[13], z, col[15], col[16],
                              col[17], col[18], col[19], col[20], col[21],
                              col[22], col[23], col[24], col[25], col[26],
                              col[27], col[28], col[29], col[30], col[31])
                    select_sql((sql2, campos))
            """
            6. Insertamos las deducciones
            """

            sql1 = sql + ("and not esdevengo "
                          "ORDER by "
                          "idemp_contrato, orden")
            h = select_sql((sql1, (filas[1])), 1)
            k = select_sql("Select max(idnomina_devengo) + 1 "
                           "from nomina_devengos")[0]
            print "*********************** Deducciones "

            for col in h:
                print '    ', col[2], col[3]
                orden += 1
                if not k:
                    k = 1
                else:
                    k += 1
                campos = (k, j, col[0], orden, col[2], col[3], col[4], col[5],
                          col[6], col[7], col[8], col[9], col[10], col[11],
                          col[12], col[13], z, col[15], col[16], col[17],
                          col[18], col[19], col[20], col[21], col[22], col[23],
                          col[24], col[25], col[26], col[27], col[28], col[29],
                          col[30], col[31])
                select_sql((sql2, campos))
        # self.actualizar = Actualizar(j)
        return