def valorcelda(self, celda, nomina, c, idform_celda, *campo):
# # Funcion que nos devuelve el contenido de la celda
# de la cabecera y del pie
# celda es idform_concepto
try:
sql = ("select " + unicode(campo[0]) +
" from nomina_devengos "
" where idnomina = %s and idform_concepto = %s")
reg = select_sql((sql, (nomina, celda)))[0]
except:
try:
reg = SqlNominas(nomina).dato_nomina(campo[0])
if not reg:
reg = SqlNominas(nomina).__dict__[campo[0]]
except:
pass
dataform = FormCelda(idform_celda)
c.setFillGray(0)
c.setFont("Courier", 9)
# Comprobamos que los datos de fecha y valor queden como string correcto
if campo[0] == 'fecha':
reg = SqlNominas(nomina).fecha_formlargo
if isinstance(reg, float):
reg = "{:,.2f}".format(reg)
if reg is not None:
dataform.dato_draw(c,reg)
def __init__(self,
mes,
anio,
empresa,
trabajador=0,
esnomina=True,
esfiniquito=False,
esnominapextra=False):
"""
Constructor
"""
self.mes = mes
self.anio = anio
self.dia = ultimodiames(mes, anio)
self.fecha = str(self.anio) + "-" + str(self.mes) + "-" + str(self.dia)
self.empresa = empresa
self.es_finiquito = esfiniquito
self.es_nomina = esnomina
self.es_nominapextra = esnominapextra
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.trabajador_id = trabajador
self.SqlNom = SqlNominas()
self.cabecera = Cabecera(self.empresa, self.mes, self.anio,
self.trabajador_id)
print "*********** ALTA NOMINA **************"
print 'Nomina:', self.es_nomina, ' Finiquito:', self.es_finiquito
self.nominas_empresa()
def actual_dietas(self, nomina):
# --------- Calculo de las dietas dado un importe fijo neto
SN = SqlNominas(nomina)
neto = SN.contrato.liquido_a_cobrar
if neto > 0:
self.calc_dietas(nomina)
print "Volvemos a actualizar"
Actualizar(nomina)
else:
print " No hay dietas ...."
def __init__(self, nomina):
self.idnomina = nomina
self.datos = SqlNominas(self.idnomina)
self.anio = self.datos.fecha_anio(self.idnomina)
self.mes = self.datos.fecha_mes(self.idnomina)
self.dia_inicial = self.datos.periodos(self.anio, self.mes,
self.idnomina)[0]
self.dia_final = self.datos.periodos(self.anio, self.mes,
self.idnomina)[1]
self.fecha = self.datos.periodos(self.anio, self.mes, self.idnomina)[1]
def __init__(self, idnomina=0):
'''
Constructor
'''
self.id = idnomina
self.nomina = SqlNominas(self.id)
importe = 0
for x in self.nomina.lista_devengos_nomina():
self.devengo = Nomina_Devengo(x[0])
importe = self.devengo.paga_extra() + importe
print "paga extra", self.devengo.id, importe
def imprimir(self):
SqlNom = SqlNominas()
self.formulario
self.canvas = canvas.Canvas("nomina.pdf", pagesize=A4)
impr_nomina(
self.canvas,
self.empresa().id, self.mes, self.anio, self.formulario,
SqlNom.nomina_trabajador_mes(self.trabajador().id, self.mes,
self.anio))
self.canvas.save()
print os.name
os.system("/usr/bin/evince nomina.pdf")
def __init__(self, nomina):
self.id = nomina
self.nomina = SqlNominas(self.id)
self.grupo_cot_id = self.nomina.grupo_cotizacion_id
self.anio = self.nomina.fecha_anio
self.mes = self.nomina.fecha_mes
self.contrato_id = self.nomina.contrato_id
self.cta_cot_id = self.nomina.cta_cot_id
self.coef_pextra = self.nomina.cta_cot.coef_pextra
self.lista_devengos = self.nomina.lista_devengos_nomina()
self.lista_pextra = self.nomina.lista_pagas_extras()
self.calendario = Calendario(self.cta_cot_id, self.anio)
self.bases_cotizacion()
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 ..."
def __init__(self, nomina):
"""
Gestiona el cálculo de la IT del trabajador respecto de una nomina dada
"""
self.id = nomina
self.SqlNom = SqlNominas(self.id)
self.mes = self.SqlNom.fecha_mes
self.anio = self.SqlNom.fecha_anio
self.it = It_registro(self.buscar_it_nomina())
self.it_fechas_mes = self.it.periodo_it(self.anio, self.mes)
self.it_fecha_inicial = self.it_fechas_mes[0]
self.it_fecha_final = self.it_fechas_mes[1]
self.it_dias_mes = (self.it_fecha_final - self.it_fecha_final).days + 1
self.it_fechas_acumulado_total = self.it.periodo_it(
self.anio, self.mes, True)
self.it_dias_acumulados = (self.it_fechas_acumulado_total[1] -
self.it_fechas_acumulado_total[0]).days + 1
self.it_dias_pendientes = self.it_dias_acumulados
def on_change(self, entry, data=None):
self.tabla.destroy()
empresa = SqlNominas(0)
trabajadores = empresa.trabajadores(valor_combobox(self.cbnum),
valor_combobox(self.cbmes),
self.anio.get_text(),
self.esnomina, self.esfiniquito,
self.esnominapextra)
tabla = Gtk.Table(10, 1)
t = 0
while t < len(trabajadores):
boton = Gtk.Button(trabajadores[t][0])
boton.connect("clicked", self.clicked, trabajadores[t][1])
boton.show()
tabla.attach(boton, 0, 1, t, t + 1)
t += 1
self.tabla = tabla
self.tabla.show()
self.box9.add(self.tabla)
self.box9.show()
def bases_cotizacion(self):
'''
:return:
'''
self.base_irpf = 0
self.base_remuneracion = 0
self.base_irpf_especie = 0
self.base_ppextra = 0
self.base_irpf_segsoc = 0
self.base_segsoc_sinirpf = 0
self.base_irpf_sinsegsoc = 0
self.no_cotizan = 0
self.nomina.actualiza_ppextra()
self.nomina = SqlNominas(self.id)
self.base_ppextra = self.nomina.base_ppextra
# Para calcular las bases de cotización distinguimos entre devengos y pagas extras
# Comprobamos que los devengos cotizan a la seguridad social al igual que las pagas extras
# Comprobamos que los devengos cotizan en el IRPF al igual que las pagas extras
# Los prorrateos de pagas extras se calculan en SqlNominas.devengo_ppextra()
for x in (self.lista_devengos + self.lista_pextra):
devengo = Nomina_Devengo(x[0])
print ' ....****>>>> Devengo/segsoc/irpf', devengo.concepto, devengo.cotiza_segsocial, devengo.cotiza_irpf
if devengo.cotiza_segsocial:
self.base_remuneracion = self.base_remuneracion + devengo.devengado
if devengo.cotiza_irpf:
if devengo.es_devengo_especie:
self.base_irpf_especie = self.base_irpf_especie + devengo.devengado
else:
self.base_irpf = self.base_irpf + devengo.devengado
if devengo.cotiza_irpf and devengo.cotiza_segsocial:
self.base_irpf_segsoc = self.base_irpf_segsoc + devengo.devengado
if not devengo.cotiza_irpf and devengo.cotiza_segsocial:
self.base_segsoc_sinirpf = self.base_segsoc_sinirpf + devengo.devengado
if devengo.cotiza_irpf and not devengo.cotiza_segsocial:
self.base_irpf_sinsegsoc = self.base_irpf_sinsegsoc + devengo.devengado
if not devengo.cotiza_irpf and not devengo.cotiza_segsocial:
self.no_cotizan = self.no_cotizan + devengo.devengado
self.base_segsocial = self.base_ppextra + self.base_remuneracion
def calc_dietas(self, nomina):
"""
Se tienen en cuenta:
1. Bases que cotizan en seg.social e irpf (incluidas las pagas extras)
2. Bases que solo cotizan en seg. social o irpf
3. Bases que no cotizan ni en seg.social ni en irpf
4. Bases para las pagas extras
5. Tipos de cotizacion
"""
bd = Basedatos()
cursor = bd.conectar()
# ----------- 1. Bases que cotizan en seg.social e irpf
costes = CostesSegSocial(nomina)
self.b_segsoc_irpf = costes.bases.base_irpf_segsoc
print " Base segsoc, irpf", self.b_segsoc_irpf
if not self.b_segsoc_irpf:
self.b_segsoc_irpf = 0
# ------------ 2a. Bases que cotizan solo en seg.social
self.b_segsoc = costes.bases.base_segsoc_sinirpf
print " Base segsoc", self.b_segsoc
if not self.b_segsoc:
self.b_segsoc = 0
# ------------ 2b. Bases que cotizan solo en irpf
self.b_irpf = costes.bases.base_irpf_sinsegsoc
print " Base irpf", self.b_irpf
if not self.b_irpf:
self.b_irpf = 0
# ------------ 3. Bases que no cotizan ni en seg.social ni en irpf
self.base = costes.bases.no_cotizan
print " Bases ", self.base
if not self.base:
self.base = 0
# ------------ Tipos de cotizacion seg. social
self.tipo_segsoc = costes.tipo_ccomun_trab
self.tipo_segsoc = self.tipo_segsoc + costes.tipo_desempleo_trab
self.tipo_segsoc = self.tipo_segsoc + costes.tipo_fp_trab
self.tipo_segsoc /= 100
print " Tipo seg_social ", self.tipo_segsoc
# ----------- Tipos de irpf
self.tipo_irpf = self.nomina.tipo_irpf(nomina) / 100
print " Tipo irpf ", self.tipo_irpf
# ---------- Calculo de dietas
SN = SqlNominas(nomina)
devengo = costes.bases.nomina.total_devengos
print " ********* Devengo", devengo
neto = SN.contrato.liquido_a_cobrar
print " ********* Neto", neto
basess = costes.base_cotizacion
baseirpf = costes.bases.base_irpf
"""
self.dietas = (self.neto - (self.b_segsoc_irpf *
(1 - self.tipo_segsoc - self.tipo_irpf)) -
(self.b_segsoc * (1 - self.tipo_segsoc)) +
(self.ppextra * self.tipo_segsoc) -
(self.b_irpf * (1 - self.tipo_irpf)) -
self.base)
"""
self.dietas = (neto - devengo + basess * self.tipo_segsoc + baseirpf * self.tipo_irpf) / (
1 - self.tipo_segsoc - self.tipo_irpf)
print " Dietas", self.dietas
sql = ("SELECT irpf, cont_com "
"FROM nomina_devengos "
"WHERE esdieta and idnomina = %s;")
cursor.execute(sql, (nomina))
self.coef_dieta = cursor.fetchone()
if self.coef_dieta[0] == '\x00':
self.tipo_irpf = 0
if self.coef_dieta[1] == '\x00':
self.tipo_segsoc = 0
#self.dietas = self.dietas / (1 - self.tipo_segsoc - self.tipo_irpf)
sql = ("UPDATE nomina_devengos "
"SET imp_precio = %s, imp_devengo = %s, importe = %s "
"WHERE idnomina=%s and esdieta ")
cursor.execute(sql, (self.dietas, self.dietas, self.dietas, nomina))
bd.desconectar()
print " Fin calculo dietas ... ", self.dietas
def on_bEliminar_clicked(self, button, data=None):
SqlNominas(self.lanomina).borrar_nomina()
self.nomina()
def nomina(self):
self.lista = Gtk.ListStore(long, str, str, str, str, str)
render0 = Gtk.CellRendererText()
render0.set_property("xalign", 1.0)
render0.set_property("visible", False)
render1 = Gtk.CellRendererText()
render1.set_property("xalign", 0)
render2 = Gtk.CellRendererText()
render2.set_property("xalign", 1.0)
render2.set_property("editable", True)
render2.connect('edited', self.col2_edited_cb, self.lista)
render3 = Gtk.CellRendererText()
render3.set_property("xalign", 1.0)
render3.set_property("editable", True)
render3.connect('edited', self.col3_edited_cb, self.lista)
render4 = Gtk.CellRendererText()
render4.set_property("xalign", 1.0)
render5 = Gtk.CellRendererText()
render5.set_property("xalign", 1.0)
SqlNom = SqlNominas(self.lanomina)
#devengos = SqlNom.ver_devengos(self.trabajador, self.mes, self.anio)
# self.tabla = Gtk.Table(len(devengos[0]),len(devengos))
lista_devengos = SqlNom.lista_devengos_nomina(
) + SqlNom.lista_pagas_extras()
for k in lista_devengos:
contenido = []
devengo = Nomina_Devengo(k[0])
#for l in k:
# entrada = Gtk.Label(devengos[t][p])
# self.tabla.attach(entrada,p,p+1,t,t+1)
# entrada.show()
# print "Dev",devengos[t][p],t, p
#if isinstance(devengo.precio, float):
# l = "{0:,.2f}".format(l)
decimales = '{0:,.2f}'
contenido.append(devengo.id)
contenido.append(devengo.concepto)
contenido.append(decimales.format(devengo.cuantia))
contenido.append(decimales.format(devengo.precio))
contenido.append(decimales.format(devengo.devengado))
contenido.append(decimales.format(devengo.deducido))
self.lista.append(contenido)
self.vista.set_model(self.lista)
col1 = Gtk.TreeViewColumn("Num.", render0, text=0)
col2 = Gtk.TreeViewColumn("Concepto", render1, text=1)
col3 = Gtk.TreeViewColumn("Cant.", render2, text=2)
col4 = Gtk.TreeViewColumn("Precio", render3, text=3)
col5 = Gtk.TreeViewColumn("Devengo", render4, text=4)
col6 = Gtk.TreeViewColumn("Deduccion", render5, text=5)
self.vista.append_column(col1)
self.vista.append_column(col2)
self.vista.append_column(col3)
self.vista.append_column(col4)
self.vista.append_column(col5)
self.vista.append_column(col6)
self.vista.set_search_column(0)
cabecera = SqlNom.ver_nomina(self.trabajador, self.mes, self.anio)
self.lcif.set_text(SqlNom.cif)
self.lcontrato.set_text(SqlNom.contrato.contrato.descripcion)
ldir = SqlNom.cta_cot.centro_trabajo.dir_calle + ', ' + SqlNom.cta_cot.centro_trabajo.dir_numero
self.ldireccion.set_text(ldir)
self.lhoras.set_text(unicode(SqlNom.horas_cotizadas()))
self.lidcontrato.set_text(unicode(SqlNom.contrato.codigo))
self.lidnomina.set_text(unicode(SqlNom.id))
self.lnaf.set_text(SqlNom.naf)
self.lnif.set_text(SqlNom.nif)
self.lncc.set_text(SqlNom.cta_cot.cuenta_cotizacion)
self.lnumcontrato.set_text(unicode(SqlNom.contrato.idcontrato))
self.lperiodo.set_text("Del " + SqlNom.periodo)
try:
self.lppextra.set_text("{:,.2f}".format(SqlNom.base_ppextra))
self.lremuneracion.set_text("{:,.2f}".format(SqlNom.imp_remumes))
except:
pass
self.lpuesto.set_text(SqlNom.puesto)
self.lempresa.set_text(SqlNom.nombreempresa)
self.ld.set_text(unicode(SqlNom.dias_cotizados()))
self.lantiguedad.set_text(str(cabecera[2]))
if SqlNom.contrato.contrato.es_tiempo_parcial:
self.rb_es_tpoparcial.set_active(True)
elif SqlNom.contrato.contrato.es_tiempo_completo:
self.rb_es_tpocompleto.set_active(True)
if SqlNom.contrato.contrato.es_indefinido:
self.rb_es_indefinido.set_active(True)
elif SqlNom.contrato.contrato.es_temporal:
self.rb_es_temporal.set_active(True)
self.ltrabajador.set_text(SqlNom.nombre_trabajador)
self.lb_irpf.set_text("{:,.2f}".format(SqlNom.base_irpf))
self.lliquido.set_text('{:,.2f}'.format(SqlNom.liquido))
self.lb_segsoc.set_text("{:,.2f}".format(SqlNom.base_cc))
self.vista.show()
seleccion = self.vista.get_selection().get_selected()
# self.tabla.show()
# self.box14.add(self.tabla)
self.box14.show()
def __init__(self,
trabajador,
mes,
anio,
fornom,
esnomina=True,
esfiniquito=False,
esnominapextra=False):
self.trabajador = trabajador
self.mes = mes
self.anio = anio
self.fornom = fornom
self.gladefile = "Ventanas/nomina.glade"
self.builder = Gtk.Builder()
self.builder.add_from_file(self.gladefile)
self.builder.connect_signals(self)
self.bAceptar = self.builder.get_object("bAcepta")
self.bBorrar = self.builder.get_object('bEliminar')
self.bCancelar = self.builder.get_object("bCancela")
self.bRecalcular = self.builder.get_object("bRecal")
self.esnomina = esnomina
self.esfiniquito = esfiniquito
self.esnominapextra = esnominapextra
self.lantiguedad = self.builder.get_object("lantiguedad")
self.lidempresa = self.builder.get_object("lidempresa")
self.lcif = self.builder.get_object("lcif")
self.lcontrato = self.builder.get_object('lcontrato')
self.ld = self.builder.get_object("ld")
self.ldireccion = self.builder.get_object('ldireccion')
self.lempresa = self.builder.get_object("lemp")
self.lhoras = self.builder.get_object('lhoras')
self.lidcontrato = self.builder.get_object('lidcontrato')
self.lliquido = self.builder.get_object('lliquido')
self.lncc = self.builder.get_object("lncc")
self.lnif = self.builder.get_object("lnif")
self.lnaf = self.builder.get_object("lnaf")
self.lnumcontrato = self.builder.get_object('lnumcontrato')
self.lidnomina = self.builder.get_object('lidnomina')
self.lperiodo = self.builder.get_object("lper")
self.lpuesto = self.builder.get_object('lpuesto')
dev = SqlNominas(0)
self.lanomina = dev.nomina_trabajador_mes(self.trabajador, self.mes,
self.anio, self.esnomina,
self.esfiniquito,
self.esnominapextra)
self.laempresa = dev.trabajador_empresa(self.trabajador, self.mes,
self.anio)
self.lppextra = self.builder.get_object('lppextra')
self.lremuneracion = self.builder.get_object('lremuneracion')
self.ltrabajador = self.builder.get_object("ltrab")
self.lb_segsoc = self.builder.get_object("lb_segsoc")
self.lb_irpf = self.builder.get_object("lb_irpf")
self.rb_es_tpoparcial = self.builder.get_object("rbEs_tpoparcial")
self.rb_es_tpocompleto = self.builder.get_object('rbEs_tpocompleto')
self.rb_es_indefinido = self.builder.get_object('rbEs_indefinido')
self.rb_es_temporal = self.builder.get_object('rbEs_temporal')
self.box14 = self.builder.get_object("box14")
self.vista = self.builder.get_object("vista")
self.window3 = self.builder.get_object("window3")
self.window3.show()
if self.esnomina:
self.nomina()
elif self.esfiniquito:
self.nomina()
def datos(self, c, num_empresa, mes, anio, formnom, es_una_nomina):
# introducimos los datos en el formato que imprime solo nominas y no finiquitos
# para imprimir finiquito ha de seleccionar una a una la nomina
nominas = SqlNominas(0).idnom_mes(self.num_empresa, self.mes, self.anio, es_una_nomina)
y = 0
for p in nominas:
FormNomina(formnom).formnomina_listaid(c) # pintamos todas las cajas
celdas = FormNomina(formnom).formnomina_listatablas() # preparamos la impresion de los campos de las tablas
z = 0
for j in celdas:
dataform = FormCelda(j[0])
if dataform.formconcepto_id: # si hay un concepto de formulario enlazado
sql = ("Select " + dataform.campo + ", ancho_dato, "
" datoalineacion, idform_celda, orden, concepto, print_etiqueta "
"from "
" form_nomina_celda A "
" inner join "
" nomina_devengos B "
" on convert(A.dato, unsigned integer) = B.idform_concepto "
"where "
" idform_concepto = %s "
" and idnomina = %s "
"group by "
" concepto ")
valores = select_sql((sql, (dataform.formconcepto_id, p[0])), 1)
if valores:
for h in valores:
if dataform.label_print:
self.concepto(dataform.formconcepto_id, p[0], h[4],
dataform.dato_ancho, c, dataform.id, dataform.label_print)
self.valorcelda(dataform.formconcepto_id, p[0], c, dataform.id, dataform.campo)
else:
sql = (
"Select " + dataform.campo + ", idnomina "
" from " + dataform.tabla +
" where idnomina = " + unicode(p[0])
)
valores = select_sql(sql, 1)
if valores:
for h in valores:
self.valorcelda(dataform.formconcepto_id, p[0], c, dataform.id, dataform.campo)
try:
pass
#self.valorcelda(dataform.formconcepto_id, nominas[y][0], c, dataform.id, dataform.campo)
except MySQLdb.Error, e:
print "Error",e
sql = ("Select " + dataform.campo + ", orden "
"from nomina_devengos "
"where idnomina = %s;")
try:
concept = select_sql((sql, (nominas[y][0])), 1)
w = 0
for k in concept:
print 'Paso por aqui'
self.concepto(dataform.formconcepto_id,
nominas[y][0],
w[1],
dataform.dato_ancho,
c, dataform.id,
dataform.label_print)
w += 1
except MySQLdb.Error, e:
print "Error",e
z += 1
