def get_margen(tipo):
config_model = DataModel('Configuracion')
margen = config_model.get_records(parametro = tipo)
if len(margen) > 0:
for item in margen:
return item
return None
def _load_proveedor_combobox(self):
model = DataModel('Proveedor')
proveedores = model.get_records()
combo_model = gtk.ListStore(int, str)
for row in proveedores:
combo_model.append([int(row['id']), row['nombre']])
self.proveedor.set_model(combo_model)
self.proveedor.show()
def __run_reporte(self):
model_producto = DataModel('Producto')
model_proveedor = DataModel('Proveedor')
if self.__agotados:
productos = model_producto.get_records_from_query('SELECT * FROM Producto WHERE existencia <= 0 ORDER BY nombre ASC')
else:
productos = model_producto.get_records(order='nombre ASC')
c = canvas.Canvas('ReporteProductos.pdf', pagesize=landscape(letter))
self.__add_page_header(c)
total = 0
if len(productos) > 0:
y = 490
for producto in productos:
c.drawString(20, y, str(producto['id']))
nombre = producto['nombre'] if len(producto['nombre']) <= 20 else producto['nombre'][:19]
c.drawRightString(270, y, nombre)
proveedor = model_proveedor.get_record(producto['proveedor'])
if proveedor:
prov_nombre = proveedor['nombre'] if len(proveedor['nombre']) <= 20 else proveedor['nombre'][:19]
c.drawRightString(460, y, prov_nombre)
try:
c.drawRightString(550, y, '{:20,.2f}'.format(float(producto['precio_compra'])))
c.drawRightString(660, y, '{:20,.2f}'.format(float(producto['precio_venta'])))
c.drawRightString(760, y, str(producto['existencia']))
except:
pass
y -= 20
if y <= 80:
self.__add_page_footer(c)
y = 490
c.showPage()
self.__add_page_header(c)
total += 1
c.drawRightString(650, 60, 'T O T A L D E P R O D U C T O S: ' + str(total))
self.__add_page_footer(c)
c.showPage()
c.save()
reader = get_pdf_reader()
if reader and reader['valor'] != '':
subprocess.Popen([reader['valor'], "ReporteProductos.pdf"])
class VentasFactory(gtk.Frame):
__id_venta = 0
def __init__(self, main):
super(VentasFactory, self).__init__()
self.main = main
self.builder = gtk.Builder()
self.builder.add_from_file("ventas_frame.glade")
self.builder.connect_signals(self)
content = self.builder.get_object("vbox_content")
content.reparent(self)
content.show()
self.form_builder = FormBuilder(self.builder, 'Producto')
self.producto_model = self.form_builder.get_model()
self.venta_model = DataModel('Venta')
self.venta_detalle_model = DataModel('VentaDetalle')
self.ventas_grid = self.builder.get_object('ventas_grid')
self._load_ventas_grid()
self.form_builder.load_widget_value('fecha_hora_label',
datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S"))
self.idevent = gobject.timeout_add(1000, self._update_fecha_hora)
def on_buscar_producto_button_clicked(self, widget):
if self.__id_venta != 0:
self._show_error_message('Esta visualizando el detalle de una venta realizada, de click en el boton nuevo para realizar una nueva venta')
return
busqueda = BusquedaWindow('Producto', self._load_producto,
search_fields={'id': 'match', 'nombre': 'like'},
display_fields=['id', 'nombre', 'precio_venta', 'existencia'])
def on_buscar_button_clicked(self, widget):
busqueda = BusquedaWindow('Venta', self._load_venta,
search_fields={'id': 'match', 'fecha_sistema': 'match'},
display_fields=['id', 'fecha_sistema', 'sub_total', 'impuesto', 'total'])
def on_agregar_button_clicked(self, widget):
if self.__id_venta != 0:
self._show_error_message('Esta visualizando el detalle de una venta realizada, de click en el boton nuevo para realizar una nueva venta')
return
id_producto = self.form_builder.get_widget_value('id_producto')
if id_producto == '' or id_producto == '0':
self._show_error_message('Escriba un código de producto valido')
return
nombre_producto = self.form_builder.get_widget_value('nombre_producto')
if nombre_producto.strip() == '':
self._show_error_message('Escriba una descripción del producto')
return
precio_producto = self.form_builder.get_widget_value('precio_producto')
try:
precio_producto = Decimal(precio_producto)
if precio_producto < 0:
raise NameError('Precio no valido')
except:
self._show_error_message('Escriba un precio valido')
return
cantidad_producto = self.form_builder.get_widget_value('cantidad_producto')
try:
cantidad_producto = int(cantidad_producto)
if cantidad_producto == 0:
raise NameError('Cantidad no valida')
except:
self._show_error_message('Escriba una cantidad valida')
return
append = True
producto = self.producto_model.get_record(id_producto)
if producto:
if producto['existencia'] < cantidad_producto:
self._show_error_message('No existe la cantidad necesaria del producto en inventario')
return
for row in self.ventas_grid_model:
if row[0] == id_producto:
row[2] = int(row[2]) + cantidad_producto
row[4] = str(round(int(row[2]) * Decimal(row[3]), 2))
append = False
break
if append:
self.ventas_grid_model.append([str(id_producto), nombre_producto,
str(cantidad_producto), str(round(precio_producto, 2)),
str(round(cantidad_producto * precio_producto, 2))])
self._clear_producto(True)
self._ensure_ventas_grid()
self._calcular_totales()
gobject.source_remove(self.idevent)
else:
self._show_error_message('El codigo de producto no existe')
def on_eliminar_butto_clicked(self, widget):
if self.__id_venta != 0:
self._show_error_message('Esta visualizando el detalle de una venta realizada, de click en el boton nuevo para realizar una nueva venta')
return
selection = self.ventas_grid.get_selection()
model, treeiter = selection.get_selection_selected()
if treeiter:
del model[treeiter]
self._ensure_ventas_grid()
self._calcular_totales()
def on_iva_check_toggled(self, widget):
self._calcular_totales()
def _load_producto(self, value):
self.form_builder.load_widget_value('id_producto', value)
def id_producto_key_release_event_cb(self, widget, ev, data=None):
if ev.keyval == 65293:
producto_id = widget.get_text()
producto = self.producto_model.get_record(producto_id)
self._clear_producto()
if producto:
self._load_producto_information(producto)
def on_nuevo_button_clicked(self, widget):
self.__id_venta = 0
self._clear_producto(True)
self._clear_venta()
self.ventas_grid_model.clear()
self._ensure_ventas_grid()
self._update_fecha_hora()
def on_guardar_button_clicked(self, widget, upsert=False):
total = self.form_builder.get_widget_value('total_label').replace(',', '').strip()
cambio = 0
pago_recibido = self.form_builder.get_widget_value('pago_recibido').replace(',', '').strip()
try:
pago_recibido = float(pago_recibido)
total_numero = float(total)
if pago_recibido <= 0 or pago_recibido < total_numero:
raise NameError('Cantidad no valida')
else:
cambio = pago_recibido - total_numero
except:
self._show_error_message('La cantidad recibida de pago no es valida')
return
if self.__id_venta == 0:
if self._show_save_continue() != -9:
fecha_hora = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
fecha_sistema = datetime.datetime.now().strftime("%Y/%m/%d")
sub_total = self.form_builder.get_widget_value('subtotal_label').replace(',', '')
impuesto = self.form_builder.get_widget_value('iva_label').replace(',', '')
id_venta = self.venta_model.create_record({'fecha_hora': fecha_hora, 'sub_total': sub_total,
'impuesto': impuesto, 'total': total, 'fecha_sistema': fecha_sistema,
'pago_recibido': str(pago_recibido).strip(),
'cambio': str(cambio).strip()})
if id_venta:
for row in self.ventas_grid_model:
producto = self.producto_model.get_record(row[0])
if producto:
self.venta_detalle_model.create_record({'venta_id': str(id_venta), 'producto_id': row[0].strip(),
'producto_precio': row[3].strip(), 'producto_cantidad': row[2].strip(),
'subtotal': row[4].strip(), 'nombre': row[1].strip()})
self.producto_model.update_record({
'existencia': str(self.normalizar_existencia(producto['existencia']) - int(row[2].strip()))},
row[0].strip())
self._show_error_message('El cambio es de %s' % '{:20,.2f}'.format(float(cambio)))
if not upsert:
self._clear_producto(True)
self._clear_venta()
self.ventas_grid_model.clear()
self._ensure_ventas_grid()
self.idevent = gobject.timeout_add(1000, self._update_fecha_hora)
else:
return id_venta
else:
return 0
else:
self._show_error_message('Esta visualizando el detalle de una venta realizada, de click en el boton nuevo para realizar una nueva venta')
def on_cancelar_button_clicked(self, widget):
page = self.parent.get_current_page()
self.parent.remove_page(page)
del self.main.pages[page]
def on_imprimir_ticket_button_clicked(self, widget):
if self.__id_venta == 0:
self.__id_venta = self.on_guardar_button_clicked(widget, True)
ticket = Ticket(self.__id_venta)
if not ticket.imprimir():
self._show_error_message('No se pudo imprimir ticket, asegurese de que la venta exista')
def _calcular_totales(self):
subtotal = 0.00
impuesto = 0.00
total = 0.00
for row in self.ventas_grid_model:
precio = Decimal(row[3]) * int(row[2])
subtotal += round(precio, 2)
if self.form_builder.get_widget_value('iva_check'):
impuesto = round(subtotal * 0.16, 2)
self.form_builder.load_widget_value('iva_label', '{:20,.2f}'.format(impuesto))
else:
self.form_builder.load_widget_value('iva_label', '0.00')
total = round(subtotal + impuesto, 2)
self.form_builder.load_widget_value('subtotal_label', '{:20,.2f}'.format(subtotal))
self.form_builder.load_widget_value('total_label', '{:20,.2f}'.format(total))
def _load_ventas_grid(self):
self.ventas_grid_model = gtk.ListStore(str, str, str, str, str)
count = 0
columns = ['Id Producto', 'Producto', 'Cantidad', 'Precio', 'Subtotal']
sizes = [50, 200, 60, 100, 100]
for column in columns:
render = gtk.CellRendererText()
column_instance = gtk.TreeViewColumn(column, render, text=count)
column_instance.set_min_width(sizes[count])
self.ventas_grid.append_column(column_instance)
count += 1
self._ensure_ventas_grid()
def _ensure_ventas_grid(self):
self.ventas_grid.set_model(self.ventas_grid_model)
self.ventas_grid.show()
def _load_producto_information(self, row):
self.form_builder.load_widget_value('nombre_producto', row['nombre'])
self.form_builder.load_widget_value('precio_producto', row['precio_venta'])
self.form_builder.load_widget_value('cantidad_producto', '0')
self.builder.get_object('cantidad_producto').grab_focus()
def _clear_producto(self, clear_id=False):
if clear_id:
self.form_builder.load_widget_value('id_producto', '')
self.form_builder.load_widget_value('nombre_producto', '')
self.form_builder.load_widget_value('precio_producto', '0.00')
self.form_builder.load_widget_value('cantidad_producto', '0')
def _clear_venta(self):
self.form_builder.load_widget_value('subtotal_label', '0.00')
self.form_builder.load_widget_value('total_label', '0.00')
self.form_builder.load_widget_value('iva_label', '0.00')
self.form_builder.load_widget_value('pago_recibido', '0.00')
def _show_error_message(self, message):
dialog = gtk.MessageDialog(self.parent.parent.parent, gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, message)
dialog.run()
dialog.destroy()
def _show_save_continue(self):
dialog = gtk.MessageDialog(self.parent.parent.parent, gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, '¿Desea guardad la venta actual?')
response = dialog.run()
dialog.destroy()
return response
def _update_fecha_hora(self):
self.form_builder.load_widget_value('fecha_hora_label',
datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S"))
self.idevent = gobject.timeout_add(1000, self._update_fecha_hora)
def _load_venta(self, value):
venta = self.venta_model.get_record(int(value))
if venta:
self._clear_producto(True)
self._clear_venta()
self.ventas_grid_model.clear()
self._ensure_ventas_grid()
self.__id_venta = venta['id']
self.form_builder.load_widget_value('subtotal_label', '{:20,.2f}'.format(float(venta['sub_total'])))
self.form_builder.load_widget_value('iva_label', '{:20,.2f}'.format(float(venta['impuesto'])))
self.form_builder.load_widget_value('total_label', '{:20,.2f}'.format(float(venta['total'])))
self.form_builder.load_widget_value('pago_recibido', '{:20,.2f}'.format(float(venta['pago_recibido'])))
gobject.source_remove(self.idevent)
self.form_builder.load_widget_value('fecha_hora_label', self._parse_fecha(str(venta['fecha_hora'])))
items = self.venta_detalle_model.get_records(venta_id=venta['id'])
if len(items) > 0:
for item in items:
self.ventas_grid_model.append([str(item['id']), item['nombre'].strip(),
str(item['producto_cantidad']).strip(), str(round(item['producto_precio'], 2)).strip(),
str(round(item['producto_cantidad'] * item['producto_precio'], 2)).strip()])
else:
self._show_error_message('La venta seleccionada no existe')
def _parse_fecha(self, fecha):
year = fecha[:4]
month = fecha[4:6]
day = fecha[6:8]
hour = fecha[8:10]
minutes = fecha[10:12]
seconds = fecha[12:14]
return "%s/%s/%s %s:%s:%s" % (year, month, day, hour, minutes, seconds)
def normalizar_existencia(self, existencia):
try:
existencia = int(existencia)
except:
if isinstance(existencia, str):
number = re.match(r"\d", existencia)
if number:
existencia = number.group(0)
else:
existencia = 0
else:
existencia = 0
return existencia
def get_pdf_reader():
config_model = DataModel('Configuracion')
pdf = config_model.get_records(parametro = 'pdf_reader')
if len(pdf) > 0:
for item in pdf:
return item
class BusquedaWindow:
def __init__(self, table_name, on_value_selected, search_fields={}, display_fields=[]):
self.on_value_selected = on_value_selected
self.model = DataModel(table_name)
builder = gtk.Builder()
builder.add_from_file("busqueda.glade")
builder.connect_signals(self)
self.window = builder.get_object("window1")
self._search_fields = search_fields
self.search_entry = builder.get_object("search_entry")
self.tree = builder.get_object("treeview1")
self.combo = builder.get_object("search_fields_combo")
self._load_search_fields()
self._build_treeview(display_fields)
self.window.show()
def _build_treeview(self, fields):
if len(fields) == 0:
self.column_names = self.model.get_colums()
else:
self.column_names = fields
self.store = gtk.ListStore(*([str] * len(self.column_names)))
count = 0
for column in self.column_names:
renderer = gtk.CellRendererText()
label = self._get_column_label(column)
self.tree.append_column(gtk.TreeViewColumn(label,
renderer, text=count))
count += 1
self._get_data()
self._ensure_tree_view()
def _ensure_tree_view(self):
self.tree.set_model(self.store)
self.tree.show()
def _load_search_fields(self):
self.store_combo = gtk.ListStore(str, str)
for key in self._search_fields.keys():
self.store_combo.append([key, self._get_column_label(key)])
self.combo.set_model(self.store_combo)
self.combo.set_active(0)
self.combo.show()
def _get_data(self, query="", values=None):
if len(query) == 0:
data = self.model.get_records()
else:
data = self.model.get_records_from_query(query, values)
for row in data:
current_row = []
for column in self.column_names:
current_row.append(str(row[column]))
if len(current_row) > 0:
self.store.append(current_row)
def _get_column_label(self, column_name):
return column_name.replace('_', ' ').title()
def on_buscar_button_clicked(self, widget):
current_selection = self.combo.get_active()
field = self.store_combo[current_selection][0]
match_type = self._search_fields[field]
value = self.search_entry.get_text()
query = "SELECT * FROM %s WHERE %s %s ? ORDER BY %s ASC" % (self.model.table_name,
field, ('=' if match_type == 'match' else 'like'), field)
values = [(value if match_type == 'match' else "%%%s%%" % value)]
model = self.tree.get_model()
model.clear()
self._get_data(query, values)
self._ensure_tree_view()
def on_cancelar_button_clicked(self, widget):
self.window.destroy()
def on_aceptar_btn_clicked(self, widget):
selection = self.tree.get_selection()
model, treeiter = selection.get_selected()
if treeiter != None:
index = None
try:
index = self.column_names.index('id')
except:
pass
if index is not None and self.on_value_selected is not None:
self.on_value_selected(model[treeiter][index])
self.window.destroy()
else:
dialog = gtk.MessageDialog(None, gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, "Debe seleccionar un registro para continuar")
dialog.run()
dialog.destroy()
def _run_reporte(self, fecha_inicio, fecha_fin):
model_venta = DataModel('Venta')
model_venta_detalle = DataModel('VentaDetalle')
model_producto = DataModel('Producto')
fecha_inicio = datetime.datetime(fecha_inicio[0], fecha_inicio[1] + 1,
fecha_inicio[2])
fecha_fin = datetime.datetime(fecha_fin[0], fecha_fin[1] + 1,
fecha_fin[2])
fecha_inicio_param = fecha_inicio.strftime("%Y%m%d000000")
fecha_fin_param = fecha_fin.strftime("%Y%m%d235959")
query = 'SELECT id, fecha_sistema, sub_total, impuesto, total, pago_recibido, cambio FROM Venta ' +\
'WHERE fecha_hora >= ? AND fecha_hora <= ?'
ventas = model_venta.get_records_from_query(query, [fecha_inicio_param,
fecha_fin_param])
c = canvas.Canvas('ReporteVentas.pdf', pagesize=letter)
if len(ventas) > 0:
self.__add_page_header(c, fecha_inicio, fecha_fin)
c.drawString(30, 680, 'Id Venta')
c.drawString(90, 680, 'Fecha')
c.drawString(180, 680, 'Sub Total')
c.drawString(310, 680, 'IVA')
c.drawString(390, 680, 'Total')
c.drawString(460, 680, 'Pagado')
c.drawString(520, 680, 'Cambio')
y = 650
total = 0.00
for venta in ventas:
total_string = str(venta['total'])
c.drawString(43, y, str(venta['id']))
c.drawString(80, y, venta['fecha_sistema'])
c.drawRightString(230, y, '{:20,.2f}'.format(float(venta['sub_total'])))
c.drawRightString(340, y, '{:20,.2f}'.format(float(venta['impuesto'])))
c.drawRightString(420, y, '{:20,.2f}'.format(float(total_string)))
c.drawRightString(500, y, '{:20,.2f}'.format(float(venta['pago_recibido'])))
c.drawRightString(560, y, '{:20,.2f}'.format(float(venta['cambio'])))
total += float(total_string)
items = model_venta_detalle.get_records(venta_id=venta['id'])
y -= 30
if len(items) > 0:
c.drawString(133, y, 'Producto')
c.drawString(253, y, 'Precio')
c.drawString(313, y, 'Cantidad')
c.drawString(413, y, 'Subtotal')
total_registros = len(items)
actual = 0
for item in items:
y -= 20
nombre = item['nombre'] if len(item['nombre']) <= 20 else item['nombre'][:19]
c.drawRightString(213, y, nombre)
c.drawRightString(280, y, '{:20,.2f}'.format(float(item['producto_precio'])))
c.drawRightString(353, y, str(item['producto_cantidad']))
c.drawRightString(453, y, '{:20,.2f}'.format(float(item['subtotal'])))
y -= 20
c.line(10, y, 600, y)
y -= 20
actual += 1
if y <= 120:
self.__add_page_footer(c)
y = 680
c.showPage()
self.__add_page_header(c, fecha_inicio, fecha_fin)
c.drawString(360, y - 20, 'T O T A L:')
c.drawRightString(520, y - 20, '{:20,.2f}'.format(total))
self.__add_page_footer(c)
c.showPage()
c.save()
reader = get_pdf_reader()
if reader and reader['valor'] != '':
subprocess.Popen([reader['valor'], "ReporteVentas.pdf"])
class Ticket:
__meses = {1: 'Enero', 2: 'Febrero', 3: 'Marzo', 4: 'Abril', 5: 'Mayo',
6: 'Junio', 7: 'Julio', 8: 'Agosto', 9: 'Septiembre',
10: 'Octubre', 11: 'Noviembre', 12: 'Diciembre'}
def __init__(self, id_venta):
self.c = canvas.Canvas('Ticket.pdf')
self.venta_model = DataModel('Venta')
self.venta_detalle_model = DataModel('VentaDetalle')
self.producto_model = DataModel('Producto')
self.id_venta = id_venta
def imprimir(self):
#1 cm = 28.346 puntos
if self.id_venta > 0:
x = get_margen('margen_izquierdo')
print x
x = 3.92 if x is None else float(x['valor'])
y = get_margen('margen_superior')
print y
y = 692.0 if y is None else float(y['valor'])
y_inicial = y
venta = self.obtener_venta()
if len(venta) == 0:
return False
self.c.setFont("Helvetica", 8)
self.c.drawString(x + 79.08, y,
str(self.fecha_parser(venta['fecha'], 'dia')))
self.c.drawString(x + 118.08, y,
str(self.fecha_parser(venta['fecha'], 'mes')))
self.c.drawString(x + 264.08, y,
str(self.fecha_parser(venta['fecha'], 'anyo')))
y -= 48.14
items = self.venta_detalle_model.get_records(venta_id=venta['id'])
if len(items) > 0:
for item in items:
piezas = ' piezas' if int(item['producto_cantidad']) > 1 else ' pieza'
self.c.drawString(x, y, str(item['producto_cantidad']) + piezas)
self.c.drawString(x + 49.91, y, item['nombre'][0:30])
self.c.drawString(x + 165.70, y, '{:20,.2f}'.format(item['producto_precio']))
self.c.drawString(x + 214.70, y, '{:20,.2f}'.format(item['subtotal']))
y -= 18.06
self.c.drawString(x + 208.08, y_inicial - 284.0,
'{:20,.2f}'.format(float(venta['total'])))
self.c.drawString(x + 49.08, y_inicial - 308.0, self.total_a_cadena(venta['total']))
self.c.showPage()
self.c.setPageSize((432, 544))
self.c.save()
reader = get_pdf_reader()
if reader and reader['valor'] != '':
subprocess.Popen([reader['valor'], "Ticket.pdf"])
return True
else:
return False
def obtener_venta(self):
venta_info = {}
venta = self.venta_model.get_record(int(self.id_venta))
if venta:
total = float(venta['total'].strip()) if not isinstance(venta['total'], float) else venta['total']
venta_info = {'id': venta['id'], 'total': total, 'fecha': venta['fecha_sistema']}
return venta_info
def fecha_parser(self, fecha, dato):
if dato is 'dia':
return int(fecha[8:10])
if dato is 'mes':
mes = int(fecha[5:7])
return self.__meses[mes]
if dato is 'anyo':
return fecha[3:4]
def total_a_cadena(self, total):
total_neto = int(float(total))
cadena = to_word(total_neto) + 'Pesos'
decimales = self.obtener_decimales(total)
cadena += ' %s/100 M.N' % decimales
return cadena
def obtener_decimales(self, total):
cadena = '{:20,.2f}'.format(total)
decimales = ''
agregar = False
index = 0
while index < len(cadena):
if agregar:
decimales += cadena[index]
if cadena[index] == '.':
agregar = True
index += 1
if decimales == '':
decimales = '00'
return decimales
