def setup_monthly_list(self, data_type):
month = core.format_date_internal(
self.combobox_month_displayed.GetValue())
date = core.datetime_today()[0]
lists = {EXPENSE: self.list_expenses, INCOME: self.list_incomes}
list_ctrl = lists[data_type]
list_ctrl.DeleteAllItems()
db = database.TransactionsDB()
transaction_registered = db.monthly_transactions_list(month, data_type)
for _transaction in transaction_registered:
category = db.categories_search_id(_transaction.category)
item = list_ctrl.Append(
(_transaction.description, core.format_id_user(
_transaction.ID), category.category if category else u'',
core.format_cash_user(_transaction.value, currency=True),
core.format_date_user(_transaction.transaction_date),
u'OK' if not _transaction.payment_pendant else u'Pendente'))
# Atribui uma cor ao item caso o pagamento ainda não tenha sido realizado
if _transaction.payment_pendant:
self.setup_item_color(item, data_type)
db.close()
def delete(self, box):
"""
Apaga uma entrada em agum dos dados do dia
:param box: TreeListCtrl da entrada
:type box: wx.gizmos.TreeListCtrl
:return:
"""
boom = box.GetSelection()
if boom == box.GetRootItem():
return
item_data = box.GetItemData(boom).GetData()
if isinstance(item_data, data_types.ProductData):
boom = box.GetItemParent(boom)
item_data = box.GetItemData(boom).GetData()
db = database.TransactionsDB()
if box is self.list_sales:
func = db.delete_sale
sale.update_inventory(item_data, undo=True)
elif box is self.list_expenses:
func = db.delete_expense
else:
func = db.delete_waste
waste.update_inventory(item_data, undo=True)
func(item_data.ID)
db.close()
self.setup(None)
def setup_monthly_expenses(self, event):
self.list_expenses.DeleteAllItems()
month = core.format_date_internal(
self.combobox_month_displayed.GetValue())
db = database.TransactionsDB()
expenses = db.monthly_transactions_list(month, transaction.EXPENSE)
db.close()
root = self.list_expenses.AddRoot(
self.combobox_month_displayed.GetValue() or u'-----')
self.list_expenses.SetItemText(root, u'Gastos Mensais', 1)
self.list_expenses.SetItemFont(
root, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
total = 0.0
for expense_ in expenses:
x = self.list_expenses.AppendItem(
root, core.format_date_user(expense_.transaction_date))
self.list_expenses.SetItemText(x, expense_.description, 1)
self.list_expenses.SetItemText(
x, core.format_cash_user(expense_.value, currency=True), 2)
self.list_expenses.SetItemData(x, wx.TreeItemData(expense_))
total += expense_.value
self.list_expenses.SetItemText(
root, core.format_cash_user(total, currency=True), 2)
self.list_expenses.ExpandAll(root)
def __init__(self, parent, title=u'Transaçoes'):
wx.Frame.__init__(self,
parent,
-1,
title,
style=wx.MINIMIZE_BOX | wx.SYSTEM_MENU | wx.CAPTION
| wx.CLOSE_BOX | wx.CLIP_CHILDREN)
self.setup_gui()
db = database.TransactionsDB()
dates = db.list_transactions_dates()
db.close()
months = list()
for date in dates:
month = core.format_date_user(date[:-3])
if month not in months:
months.append(month)
if months:
self.combobox_month_displayed.SetItems(months)
self.combobox_month_displayed.SetSelection(0)
self.setup(None)
self.Show()
def save(self, event):
fund = core.money2float(self.textbox_cash_previous.GetValue())
cash_ideal = core.money2float(self.textbox_cash_ideal.GetValue())
cash_real = core.money2float(self.textbox_cash_real.GetValue())
withdrawal = core.money2float(self.textbox_cash_removed.GetValue())
if cash_real:
cash = cash_real - withdrawal
else:
cash = cash_ideal - withdrawal
if cash < 0:
cash = 0.0
db = database.TransactionsDB()
if self.cash_register:
self.cash_register.withdrawal = withdrawal
self.cash_register.cash = cash
self.cash_register.fund = fund
db.edit_cash(self.cash_register)
else:
date = core.format_date_internal(self.combobox_day_option.GetValue())
self.cash_register = data_types.CashRegisterData()
self.cash_register.record_date = date
self.cash_register.withdrawal = withdrawal
self.cash_register.cash = cash
self.cash_register.fund = fund
db.insert_cash(self.cash_register)
db.close()
def end(self):
_product_id = self.textbox_id.GetValue()
_amount = self.textbox_amount.GetValue()
if not _product_id or not _amount:
return dialogs.launch_error(self, u'Dados insuficientes!')
date, finish_time = core.datetime_today()
data = data_types.WasteData()
data.product_ID = int(_product_id)
data.amount = float(_amount)
data.record_date = date
data.record_time = finish_time
data.ID = self.key
db = database.TransactionsDB()
if self.key != -1 or self.data:
db.edit_waste(data)
update_inventory(self.data, undo=True)
else:
db.insert_waste(data)
db.close()
update_inventory(data)
self.clean()
dialogs.Confirmation(self, u"Sucesso", 3)
def __init__(self, parent, title=u'Desperdícios', key=-1, data=None):
wx.Frame.__init__(self,
parent,
-1,
title,
size=(630, 280),
style=wx.MINIMIZE_BOX | wx.SYSTEM_MENU | wx.CAPTION
| wx.CLOSE_BOX | wx.CLIP_CHILDREN)
self.key = key
self.data = data
self.setup_gui()
self.database_inventory = database.InventoryDB(':memory:')
if self.key != -1 or data:
if not data:
db = database.TransactionsDB()
self.data = db.wastes_search_id(self.key)
db.close()
self.key = self.data.ID
self.recover_waste()
self.database_search(None)
self.Show()
def setup_wastes(self):
inventory_db = database.InventoryDB()
wastes_db = database.TransactionsDB()
waste_list = wastes_db.monthly_wastes_list(self.month)
wastes_db.close()
walist = {}
for waste_ in waste_list:
if waste_.product_ID in walist:
walist[waste_.product_ID][0] += waste_.amount
walist[waste_.product_ID][1] += 1
else:
product = inventory_db.inventory_search_id(waste_.product_ID)
walist[waste_.product_ID] = [
waste_.amount, 1, product.description, product.price,
waste_
]
self.AddColumn(u'ID', 100)
self.AddColumn(u'Descrição', 300)
self.AddColumn(u'Preço Unitário', 100)
self.AddColumn(u'Quantidade', 100)
self.AddColumn(u'Quantidade de vezes', 150)
self.AddColumn(u'Valor', 200)
root = self.AddRoot(u'------')
self.SetItemText(
root, u'Desperdícios de %s' % core.format_date_user(self.month), 1)
self.SetItemFont(root, wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
a = 0.0
b = 0.0
counter = 0
for product_id in walist:
value = walist[product_id][3] * walist[product_id][0]
item = self.AppendItem(root, str(product_id))
self.SetItemText(item, walist[product_id][2], 1)
self.SetItemText(
item,
core.format_cash_user(walist[product_id][3], currency=True), 2)
self.SetItemText(item,
core.format_amount_user(walist[product_id][0]), 3)
self.SetItemText(item, str(walist[product_id][1]), 4)
self.SetItemText(item, core.format_cash_user(value, currency=True),
5)
self.SetItemData(item, wx.TreeItemData(walist[product_id][4]))
a += value
b += walist[product_id][0]
counter += 1
self.SetItemText(root, core.format_amount_user(b), 3)
self.SetItemText(root, str(counter), 4)
self.SetItemText(root, core.format_cash_user(a, currency=True), 5)
self.Expand(root)
self.SortChildren(root)
def update_categories(self):
db = database.TransactionsDB()
category_list = db.categories_list()
category_options = [u'Selecione']
self.categories_ids = [None]
for category in category_list:
category_options.append(category.category)
self.categories_ids.append(category.ID)
self.combobox_category.SetItems(category_options)
self.combobox_category.SetSelection(0)
db.close()
def data_delete(self, box):
db = database.TransactionsDB()
item = box.GetSelection()
data = box.GetItemData(item).GetData()
db.delete_transaction(data.ID)
db.close()
func = {
self.list_incomes: self.setup_monthly_incomes,
self.list_expenses: self.setup_monthly_expenses
}
func.get(box)(None)
def end(self):
description = self.textbox_description.GetValue().capitalize()
val = core.money2float(self.textbox_value.GetValue())
if len(description) == 0 or val == 0:
return dialogs.launch_error(self, u'Dados insulficientes')
date, finish_time = core.datetime_today()
wx_date = self.calendar_date.GetDate()
transaction_date = u'%i-%s-%i' % (
wx_date.GetYear(), core.good_show(
'o', str(wx_date.GetMonth() + 1)), wx_date.GetDay())
data = data_types.TransactionData()
data.ID = self.key
data.description = description
data.category = self.categories_ids[
self.combobox_category.GetSelection()]
data.value = val
data.record_date = date
data.record_time = finish_time
data.transaction_date = transaction_date
data.type = self.transaction_type
data.payment_pendant = not self.checkbox_payed.GetValue()
db = database.TransactionsDB()
if self.key == -1:
db.insert_transaction(data)
else:
db.edit_transaction(data)
db.close()
parent = self.GetParent()
if isinstance(parent, monthly_report.Report):
funcs = {
EXPENSE: parent.setup_monthly_expenses,
INCOME: parent.setup_monthly_incomes
}
setup = funcs[self.transaction_type]
setup(None)
if self.key == -1:
self.clean()
confirmation_option = -1
if self.transaction_type is EXPENSE:
confirmation_option = 2
elif self.transaction_type is INCOME:
confirmation_option = 7
dialogs.Confirmation(self, u"Sucesso", confirmation_option)
else:
self.exit(None)
def setup_options(self):
db = database.TransactionsDB()
month_options = list()
for date in db.list_record_dates():
month_options.append(core.format_date_user(date))
db.close()
self.combobox_day_option = wx.ComboBox(self.panel_top, -1, choices=month_options, size=(130, -1),
pos=(420, 12), style=wx.CB_READONLY)
self.combobox_day_option.Bind(wx.EVT_COMBOBOX, self.setup)
if len(month_options) != 0:
self.combobox_day_option.SetSelection(0)
def setup_options(self):
db = database.TransactionsDB()
record_dates = db.list_record_dates(transactions=True, deleted=True)
transactions_dates = db.list_transactions_record_dates(deleted=True)
db.close()
day_options = core.convert_list(record_dates, core.format_date_user)
month_options = list()
for date in transactions_dates:
month = core.format_date_user(date[:-3])
if month not in month_options:
month_options.append(month)
entry_types = [
u'Gastos, Vendas e Desperdícios',
u'Clientes, Produtos e Categorias', u'Transações e Categorias'
]
self.combobox_entry_type = wx.ComboBox(self.panel_control,
choices=entry_types,
size=(230, -1),
pos=(5, 30),
style=wx.CB_READONLY
| wx.TE_MULTILINE)
self.combobox_entry_type.Bind(wx.EVT_COMBOBOX, self.data_update)
self.combobox_month_option = wx.ComboBox(self.panel_control,
-1,
choices=month_options,
size=(130, -1),
pos=(5, 100),
style=wx.CB_READONLY)
self.combobox_month_option.Bind(wx.EVT_COMBOBOX, self.setup)
self.combobox_day_option = wx.ComboBox(self.panel_control,
-1,
choices=day_options,
size=(130, -1),
pos=(5, 100),
style=wx.CB_READONLY)
self.combobox_day_option.Bind(wx.EVT_COMBOBOX, self.setup)
self.combobox_entry_type.SetSelection(1)
if len(month_options):
self.combobox_month_option.SetSelection(0)
if len(day_options):
self.combobox_day_option.SetSelection(0)
self.combobox_entry_type.SetSelection(0)
def data_delete(self, event):
if self.notebook_lists.GetSelection():
data_list = self.list_incomes
else:
data_list = self.list_expenses
it = data_list.GetFocusedItem()
if it == -1:
return
e_id = data_list.GetItem(it, 1).GetText()
db = database.TransactionsDB()
db.delete_transaction(int(e_id))
db.close()
self.setup(None)
def data_delete(self, event):
t = self.list_bought.GetFocusedItem()
if t == -1:
return
if self.list_bought.GetItemTextColour(t) is core.COLOR_LIST_ITEM_DISABLED:
activate = True
else:
activate = False
db = database.TransactionsDB()
sale_id = self.list_bought.GetItemData(t)
db.delete_sale(sale_id=sale_id, undo=activate)
db.close()
if activate:
self.list_bought.SetItemTextColour(t, wx.BLACK)
else:
self.list_bought.SetItemTextColour(t, core.COLOR_LIST_ITEM_DISABLED)
def notify_pendant_transactions(transaction_type, parent=None):
import database
import dialogs
today = core.datetime_today()[0]
advance = st.config2type(
st.CONFIG.get(st.CONFIG_SECTION_NOTIFICATIONS,
st.CONFIG_FIELD_TRANSACTION_ADVANCE), int)
limit_day = core.int2date(core.date2int(today) + advance)
db = database.TransactionsDB()
transactions = db.pendant_transactions_list(up_to=limit_day)
db.close()
for exchange in transactions:
if exchange.type == transaction_type:
gui_line.open(dialogs.TransactionNotification,
parent,
exchange,
title=exchange.description)
def sales_list(self):
self.list_bought.DeleteAllItems()
db = database.ClientsDB()
sales = db.sales_search_client(self.client_id)
db.close()
sales_db = database.TransactionsDB()
value = 0.0
value_money = 0.0
value_card = 0.0
amount = 0
amount_money = 0
amount_card = 0
for sale_ in sales:
data = sales_db.sales_search_id(sale_.sale)
if not data.active:
disconnect_sale(sale_.ID, data.ID)
continue
payed = u'Sim' if not data.payment_pendant else u'Não'
item = self.list_bought.Append((data.record_date, data.record_time,
core.format_cash_user(data.value, currency=True), payed))
self.list_bought.SetItemData(item, data.ID)
value += data.value
amount += 1
if data.payment == u'Dinheiro':
amount_money += 1
value_money += data.value
elif data.payment.split()[0] == u'Cartão':
amount_card += 1
value_card += data.value
if self.data.last_sale:
last_sale = u'Última compra registrada em %s \n' \
u'Já gastou R$ %s na Canela Santa através de %i compras, das quais %i, no valor de R$ %s,' \
u'foram pagas em dinheiro e %i, no valor de R$ %s, foram pagas no cartão.' % \
(core.format_date_user(self.data.last_sale), core.format_cash_user(value), amount, amount_money,
core.format_cash_user(value_money), amount_card, core.format_cash_user(value_card))
else:
last_sale = u'Não há nenhuma compra registrada em seu nome'
self.textbox_client_intel.SetValue(
u'Cliente desde %s \n%s'
% (core.format_date_user(self.data.record_date), last_sale))
def setup(self):
if self.data:
self.key = self.data.ID
elif self.key != -1:
db = database.TransactionsDB()
self.data = db.transactions_search_id(self.key)
db.close()
else:
return
self.textbox_description.SetValue(self.data.description)
self.textbox_value.SetValue(
core.format_cash_user(self.data.value, currency=True))
self.checkbox_payed.SetValue(not self.data.payment_pendant)
date = self.data.transaction_date.split('-')
wx_date = wx.DateTime()
wx_date.Set(int(date[2]), int(date[1]) - 1, int(date[0]))
self.calendar_date.SetDate(wx_date)
try:
self.combobox_category.SetSelection(
self.categories_ids.index(self.data.category))
except ValueError:
pass
def data_edit_payment(self, event):
if self.notebook_lists.GetSelection():
data_list = self.list_incomes
data_type = INCOME
else:
data_list = self.list_expenses
data_type = EXPENSE
it = data_list.GetFocusedItem()
if it == -1:
return
key = data_list.GetItemText(it, 1)
payment = data_list.GetItemText(it, 5)
undo = True if payment == u'OK' else False
db = database.TransactionsDB()
db.edit_transaction_payment(key, undo=undo)
db.close()
data_list.SetStringItem(it, 5, u'OK' if not undo else u'Pendente')
self.setup_item_color(it, data_type)
def setup_products(self):
inventory_db = database.InventoryDB()
sales_db = database.TransactionsDB()
sale_list = sales_db.monthly_sales_list(self.month)
sales_db.close()
plist = {}
categories_dict = {}
for sale_ in sale_list:
for i in range(len(sale_.products_IDs)):
key = sale_.products_IDs[i]
if key in plist:
plist[key][0] += sale_.amounts[i]
plist[key][1] += sale_.prices[i]
plist[key][2] += 1
else:
product = inventory_db.inventory_search_id(key)
plist[key] = [
sale_.amounts[i], sale_.prices[i], 1,
product.description, product.price, product
]
category_id = plist[key][5].category_ID
if category_id in categories_dict:
categories_dict[category_id][0] += sale_.amounts[i]
categories_dict[category_id][1] += sale_.prices[i]
categories_dict[category_id][2] += 1
else:
category = inventory_db.categories_search_id(category_id)
categories_dict[category_id] = [
sale_.amounts[i], sale_.prices[i], 1,
category.category, category, None
]
inventory_db.close()
self.AddColumn(u'ID', 100)
self.AddColumn(u'Descrição', 300)
self.AddColumn(u'Preço Unitário', 100)
self.AddColumn(u'Quantidade vendida', 135)
self.AddColumn(u'Quantidade de vezes vendido', 180)
self.AddColumn(u'Valor', 115)
root = self.AddRoot(u'------')
self.SetItemText(
root,
u'Produtos Vendidos em %s' % core.format_date_user(self.month), 1)
self.SetItemFont(root, wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
a = 0.0
b = 0.0
counter = 0
for product_id in plist:
data = plist[product_id]
category_id = data[5].category_ID
data_category = categories_dict[category_id]
if not data_category[5]:
aux = self.AppendItem(root, core.format_id_user(category_id))
self.SetItemText(aux, data_category[3], 1)
self.SetItemText(
aux,
core.format_amount_user(data[0],
unit=data_category[4].unit), 3)
self.SetItemText(aux, str(data_category[2]), 4)
self.SetItemText(
aux, core.format_cash_user(data_category[1],
currency=True), 5)
self.SetItemData(aux, wx.TreeItemData(data_category[4]))
self.SetItemFont(aux, wx.Font(11, wx.SWISS, wx.NORMAL,
wx.BOLD))
data_category[5] = aux
parent = data_category[5]
item = self.AppendItem(parent, core.format_id_user(product_id))
self.SetItemText(item, data[3], 1)
self.SetItemText(item, core.format_cash_user(data[4],
currency=True), 2)
self.SetItemText(
item,
core.format_amount_user(data[0], unit=data_category[4].unit),
3)
self.SetItemText(item, str(data[2]), 4)
self.SetItemText(item, core.format_cash_user(data[1],
currency=True), 5)
self.SetItemData(item, wx.TreeItemData(data[5]))
a += plist[product_id][1]
b += plist[product_id][0]
counter += 1
self.SetItemText(root, core.format_amount_user(b), 3)
self.SetItemText(root, str(counter), 4)
self.SetItemText(root, core.format_cash_user(a, currency=True), 5)
self.Expand(root)
self.SortChildren(root)
def __setup__(self):
if self.combobox_day_option.GetValue() != u'':
self.clean()
transactions_db = database.TransactionsDB()
inventory_db = database.InventoryDB()
day = core.format_date_internal(self.combobox_day_option.GetValue())
root = self.list_sales.AddRoot(u"Vendas de " + self.combobox_day_option.GetValue())
self.list_sales.SetItemFont(root, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
sales_value = 0.0
sales_amount = 0
money_value = 0.00
money_amount = 0
card_value = 0.00
card_amount = 0
day_sales = transactions_db.daily_sales_list(day)
for sale_item in day_sales:
sales_value += sale_item.value
sold = self.list_sales.AppendItem(root, sale_item.record_time)
self.list_sales.SetItemText(sold, sale_item.payment, 2)
self.list_sales.SetItemText(sold, core.format_cash_user(sale_item.value, currency=True), 3)
self.list_sales.SetItemFont(sold, wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
self.list_sales.SetItemData(sold, wx.TreeItemData(sale_item))
for i in range(len(sale_item.products_IDs)):
product_id = sale_item.products_IDs[i]
product = inventory_db.inventory_search_id(int(product_id))
a = self.list_sales.AppendItem(sold, product.description)
self.list_sales.SetItemText(a, core.format_amount_user(sale_item.amounts[i]), 1)
self.list_sales.SetItemText(a, core.format_cash_user(sale_item.prices[i], currency=True), 3)
self.list_sales.SetItemData(a, wx.TreeItemData(product))
if sale_item.discount:
web = self.list_sales.AppendItem(sold, u"Desconto")
self.list_sales.SetItemText(web, core.format_cash_user(sale_item.discount, currency=True), 3)
if sale_item.taxes:
bew = self.list_sales.AppendItem(sold, u"Taxas adicionais")
self.list_sales.SetItemText(bew, core.format_cash_user(sale_item.taxes, currency=True), 3)
sales_amount += 1
if sale_item.payment == u"Dinheiro":
money_amount += 1
money_value += sale_item.value
elif sale_item.payment.split()[0] == u"Cartão":
card_amount += 1
card_value += sale_item.value
self.list_sales.SetItemText(root, str(sales_amount), 1)
self.list_sales.SetItemText(root, core.format_cash_user(sales_value, currency=True), 3)
self.list_sales.Expand(root)
raz = self.list_expenses.AddRoot(self.combobox_day_option.GetValue())
expenses_value = 0.0
expenses_amount = 0
self.list_expenses.SetItemFont(raz, wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
day_expenses = transactions_db.daily_expenses_list(day)
for expense_item in day_expenses:
value = expense_item.value
description = expense_item.description
expenses_amount += 1
expenses_value += value
golf = self.list_expenses.AppendItem(raz, core.format_date_user(expense_item.record_time))
self.list_expenses.SetItemText(golf, description, 1)
self.list_expenses.SetItemText(golf, core.format_cash_user(value, currency=True), 3)
self.list_expenses.SetItemData(golf, wx.TreeItemData(expense_item))
self.list_expenses.SetItemText(raz, u"Gastos", 1)
self.list_expenses.SetItemText(raz, str(expenses_amount), 2)
self.list_expenses.SetItemText(raz, core.format_cash_user(expenses_value, currency=True), 3)
self.list_expenses.Expand(raz)
pain = self.list_wastes.AddRoot(u"Desperdícios de " + self.combobox_day_option.GetValue())
wastes_value = 0.0
wastes_amount = 0
self.list_wastes.SetItemFont(pain, wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
day_wastes = transactions_db.daily_wastes_list(day)
for wasted in day_wastes:
amount = wasted.amount
product = inventory_db.inventory_search_id(wasted.product_ID)
value = product.price * amount
wastes_amount += 1
wastes_value += value
king = self.list_wastes.AppendItem(pain, product.description)
self.list_wastes.SetItemText(king, core.format_amount_user(amount), 1)
self.list_wastes.SetItemText(king, core.format_cash_user(value, currency=True), 2)
self.list_wastes.SetItemData(king, wx.TreeItemData(wasted))
self.list_wastes.SetItemText(pain, str(wastes_amount), 1)
self.list_wastes.SetItemText(pain, core.format_cash_user(wastes_value, currency=True), 2)
self.list_wastes.Expand(pain)
self.textbox_day_total.SetValue(core.format_cash_user(sales_value - expenses_value, currency=True))
self.textbox_sales_value.SetValue(core.format_cash_user(sales_value, currency=True))
self.textbox_sales_amount.SetValue(str(sales_amount))
self.textbox_money_value.SetValue(core.format_cash_user(money_value, currency=True))
self.textbox_money_amount.SetValue(str(money_amount))
self.textbox_card_value.SetValue(core.format_cash_user(card_value, currency=True))
self.textbox_card_amount.SetValue(str(card_amount))
self.textbox_spent_value.SetValue(core.format_cash_user(expenses_value, currency=True))
self.textbox_spent_amount.SetValue(str(expenses_amount))
self.cash_register = transactions_db.cash_search_date(day)
if self.cash_register:
self.textbox_cash_previous.SetValue(core.format_cash_user(self.cash_register.fund))
self.textbox_cash_real.SetValue(core.format_cash_user(self.cash_register.cash))
self.textbox_cash_removed.SetValue(core.format_cash_user(self.cash_register.withdrawal))
else:
months = self.combobox_day_option.GetItems()
last_movement = months[self.combobox_day_option.GetSelection()-1]
cash_register = transactions_db.cash_search_date(core.format_date_internal(last_movement))
if cash_register:
self.textbox_cash_previous.SetValue(core.format_cash_user(cash_register.cash))
else:
self.textbox_cash_previous.SetValue('0,00')
self.textbox_cash_real.SetValue('0,00')
self.textbox_cash_removed.SetValue('0,00')
self.update_cash(None)
transactions_db.close()
inventory_db.close()
self.save(None)
self.combobox_day_option.Enable()
def setup_expenses(self):
expenses_db = database.TransactionsDB()
expenses = expenses_db.monthly_expenses_list(self.month)
money_exits = expenses_db.monthly_transactions_list(
self.month, transaction.EXPENSE)
expenses_db.close()
self.AddColumn(u'Data/Horário', 250)
self.AddColumn(u'Pagamento', 150)
self.AddColumn(u'Descrição', 250)
self.AddColumn(u'Quantidade', 100)
self.AddColumn(u'Valor', 150)
root = self.AddRoot(u'Gastos de %s' %
core.date_reverse(self.month).replace('-', '/'))
self.SetItemFont(root, wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
a = 0.0
b = 0
days = {}
saturdays = core.week_end(self.month)
weeks = {}
for expense_ in expenses:
for day in saturdays:
if day >= int(expense_.record_date.split('-')[2]):
week = saturdays.index(day) + 1
break
if week not in weeks:
we = self.AppendItem(root, u'%iª Semana' % week)
self.SetItemFont(we, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
weeks[week] = [we, 0.0, 0]
if expense_.record_date not in days:
item = self.AppendItem(
weeks[week][0],
core.format_date_user(expense_.record_date))
self.SetItemFont(item, wx.Font(11, wx.SWISS, wx.NORMAL,
wx.BOLD))
days[expense_.record_date] = [item, 0.0, 0]
b += 1
a += expense_.value
weeks[week][1] += expense_.value
weeks[week][2] += 1
days[expense_.record_date][1] += expense_.value
days[expense_.record_date][2] += 1
father = self.AppendItem(days[expense_.record_date][0],
expense_.record_time)
self.SetItemFont(father, wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
self.SetItemText(father, expense_.description, 2)
self.SetItemText(
father, core.format_cash_user(expense_.value, currency=True),
4)
self.SetItemData(father, wx.TreeItemData(expense_))
for j in weeks:
self.SetItemText(weeks[j][0], str(weeks[j][2]), 3)
self.SetItemText(weeks[j][0],
core.format_cash_user(weeks[j][1], currency=True),
4)
for j in days:
self.SetItemText(days[j][0], str(days[j][2]), 3)
self.SetItemText(days[j][0],
core.format_cash_user(days[j][1], currency=True),
4)
self.SortChildren(days[j][0])
if len(money_exits):
parent = self.AppendItem(root, u'Outros Gastos')
self.SetItemFont(parent, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
for money_exit in money_exits:
b += 1
a += money_exit.value
payment = u'RECEBIDO'
payment = payment if not money_exit.payment_pendant else u'AINDA NÃO ' + payment
father = self.AppendItem(
parent, core.format_date_user(money_exit.transaction_date))
self.SetItemFont(father,
wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
self.SetItemText(father, payment, 1)
self.SetItemText(father, money_exit.description, 2)
self.SetItemText(
father,
core.format_cash_user(money_exit.value, currency=True), 4)
self.SetItemData(father, wx.TreeItemData(money_exit))
self.SetItemText(root, str(b), 3)
self.SetItemText(root, core.format_cash_user(a, currency=True), 4)
self.Expand(root)
self.SortChildren(root)
def __setup__(self):
self.clean()
month = core.format_date_internal(
self.combobox_month_displayed.GetValue())
db = database.TransactionsDB()
sales = db.monthly_sales_list(month)
expenses = db.monthly_expenses_list(month)
wastes = db.monthly_wastes_list(month)
transactions = db.monthly_transactions_list(month)
db.close()
inventory_db = database.InventoryDB()
total_expense = 0.0
total_income = 0.0
total_waste = 0.0
total_card_income = 0.0
total_money_income = 0.0
dict_products = {}
week_sold = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
days = []
pendant_income = 0.0
pendant_expense = 0.0
pendant_income_count = 0
pendant_expense_count = 0
for sale_ in sales:
date_ = sale_.record_date.split('-')
week_day = calendar.weekday(int(date_[0]), int(date_[1]),
int(date_[2]))
if date_[2] not in days:
days.append(date_[2])
if not sale_.payment_pendant:
total_income += sale_.value
if sale_.payment == u'Dinheiro':
total_money_income += sale_.value
elif sale_.payment.split()[0] == u'Cartão':
total_card_income += sale_.value
week_sold[week_day] += sale_.value
else:
pendant_income += sale_.value
pendant_income_count += 1
for i in range(len(sale_.products_IDs)):
product_id = sale_.products_IDs[i]
if product_id not in dict_products:
dict_products[product_id] = [0, 0.0]
dict_products[product_id][0] += sale_.amounts[i]
dict_products[product_id][1] += sale_.prices[i]
for expense_ in expenses:
total_expense += expense_.value
for waste_ in wastes:
product = inventory_db.inventory_search_id(waste_.product_ID)
total_waste += product.price * waste_.amount
for transaction_ in transactions:
if not transaction_.payment_pendant:
if transaction_.type is transaction.INCOME:
total_income += transaction_.value
elif transaction_.type is transaction.EXPENSE:
total_expense += transaction_.value
else:
if transaction_.type is transaction.INCOME:
pendant_income += transaction_.value
pendant_income_count += 1
elif transaction_.type is transaction.EXPENSE:
pendant_expense += transaction_.value
pendant_expense_count += 1
lp1 = []
lp2 = []
for item in range(0, 11):
product_item_left = [u'', 0, 0.0, -1]
for product_id in dict_products:
if dict_products[product_id][1] > product_item_left[2]:
product_item_left = [
inventory_db.inventory_search_id(
product_id).description,
dict_products[product_id][0],
dict_products[product_id][1], product_id
]
product_item_right = [u'', 0, 0.0, -1]
for product_id in dict_products:
if dict_products[product_id][0] > product_item_right[1]:
product_item_right = [
inventory_db.inventory_search_id(
product_id).description,
dict_products[product_id][0],
dict_products[product_id][1], product_id
]
if product_item_left[2] and product_item_left not in lp1:
lp1.append(product_item_left)
if product_item_right[1] and product_item_right not in lp2:
lp2.append(product_item_right)
inventory_db.close()
for item in lp1:
item_id = self.list_left.Append(
(item[0], item[1], core.format_cash_user(item[2],
currency=True)))
self.list_left.SetItemData(item_id, item[3])
for item in lp2:
item_id = self.list_right.Append(
(item[0], item[1], core.format_cash_user(item[2],
currency=True)))
self.list_right.SetItemData(item_id, item[3])
total_balance = (total_income - total_expense)
try:
average_daily_balance = (total_income - total_expense) / len(days)
except ZeroDivisionError:
average_daily_balance = 0.0
if max(week_sold):
weekday_best = core.week_days[week_sold.index(max(week_sold))]
else:
weekday_best = '-------'
if min(week_sold):
weekday_worse = core.week_days[week_sold.index(min(week_sold))]
else:
try:
while not min(week_sold):
week_sold.remove(0.0)
weekday_worse = core.week_days[week_sold.index(min(week_sold))]
if weekday_best == weekday_worse:
weekday_worse = '-------'
except ValueError:
weekday_worse = '-------'
self.text_profit.SetValue(
core.format_cash_user(total_balance, currency=True))
self.text_spent.SetValue(
core.format_cash_user(total_expense, currency=True))
self.text_income.SetValue(
core.format_cash_user(total_income, currency=True))
self.text_wasted.SetValue(
core.format_cash_user(total_waste, currency=True))
self.text_income_pendant.SetValue(
core.format_cash_user(pendant_income, currency=True))
self.text_expense_pendant.SetValue(
core.format_cash_user(pendant_expense, currency=True))
self.text_income_pendant_amount.SetValue(str(pendant_income_count))
self.text_expense_pendant_amount.SetValue(str(pendant_expense_count))
self.text_daily_income.SetValue(
core.format_cash_user(average_daily_balance, currency=True))
self.text_credit_card_income.SetValue(
core.format_cash_user(total_card_income, currency=True))
self.text_money_income.SetValue(
core.format_cash_user(total_money_income, currency=True))
self.text_worst_week_day.SetValue(weekday_best)
self.text_better_week_day.SetValue(weekday_worse)
self.setup_monthly_incomes(None)
self.setup_monthly_expenses(None)
def setup_gui(self):
self.SetBackgroundColour(core.COLOR_DEFAULT_BACKGROUND)
self.Centre()
self.SetIcon(wx.Icon(core.ICON_MAIN, wx.BITMAP_TYPE_ICO))
part1 = wx.Panel(self,
-1,
pos=(10, 10),
size=(1180, 290),
style=wx.SUNKEN_BORDER | wx.TAB_TRAVERSAL)
self.text_profit = wx.TextCtrl(part1,
-1,
pos=(200, 50),
size=(100, 30),
style=wx.TE_READONLY)
self.text_income = wx.TextCtrl(part1,
-1,
pos=(200, 90),
size=(100, 30),
style=wx.TE_READONLY)
self.text_spent = wx.TextCtrl(part1,
-1,
pos=(200, 130),
size=(100, 30),
style=wx.TE_READONLY)
self.text_wasted = wx.TextCtrl(part1,
-1,
pos=(200, 170),
size=(100, 30),
style=wx.TE_READONLY)
self.text_income_pendant = wx.TextCtrl(part1,
-1,
pos=(200, 210),
size=(100, 30),
style=wx.TE_READONLY)
self.text_expense_pendant = wx.TextCtrl(part1,
-1,
pos=(200, 250),
size=(100, 30),
style=wx.TE_READONLY)
self.text_daily_income = wx.TextCtrl(part1,
-1,
pos=(500, 10),
size=(100, 30),
style=wx.TE_READONLY)
self.text_credit_card_income = wx.TextCtrl(part1,
-1,
pos=(500, 50),
size=(100, 30),
style=wx.TE_READONLY)
self.text_money_income = wx.TextCtrl(part1,
-1,
pos=(500, 90),
size=(100, 30),
style=wx.TE_READONLY)
self.text_worst_week_day = wx.TextCtrl(part1,
-1,
pos=(500, 130),
size=(100, 30),
style=wx.TE_READONLY)
self.text_better_week_day = wx.TextCtrl(part1,
-1,
pos=(500, 170),
size=(100, 30),
style=wx.TE_READONLY)
self.text_income_pendant_amount = wx.TextCtrl(part1,
-1,
pos=(500, 210),
size=(100, 30),
style=wx.TE_READONLY)
self.text_expense_pendant_amount = wx.TextCtrl(part1,
-1,
pos=(500, 250),
size=(100, 30),
style=wx.TE_READONLY)
self.list_left = wx.ListCtrl(part1,
-1,
pos=(625, 30),
size=(250, 240),
style=wx.SIMPLE_BORDER | wx.LC_REPORT
| wx.LC_HRULES | wx.LC_VRULES)
self.list_right = wx.ListCtrl(part1,
-1,
pos=(900, 30),
size=(250, 240),
style=wx.SIMPLE_BORDER | wx.LC_REPORT
| wx.LC_HRULES | wx.LC_VRULES)
self.list_left.InsertColumn(0, u'Descrição')
self.list_left.InsertColumn(1, u'Quantidade')
self.list_left.InsertColumn(2, u'Valor')
self.list_right.InsertColumn(3, u'Descrição')
self.list_right.InsertColumn(4, u'Quantidade')
self.list_right.InsertColumn(5, u'Valor')
wx.StaticText(part1, -1, u'Mês/Ano', pos=(10, 17))
wx.StaticText(part1, -1, u'Lucro', pos=(10, 57))
wx.StaticText(part1, -1, u'Receita', pos=(10, 97))
wx.StaticText(part1, -1, u'Custos', pos=(10, 137))
wx.StaticText(part1, -1, u'Total Perdido', pos=(10, 177))
wx.StaticText(part1,
-1,
u'Entradas Pendentes de Pagamento',
pos=(10, 217))
wx.StaticText(part1,
-1,
u'Gastos Pendentes de Pagamento',
pos=(10, 257))
wx.StaticText(part1, -1, u'Rendimento Médio por dia', pos=(310, 17))
wx.StaticText(part1, -1, u'Total Vendido no Cartão', pos=(310, 57))
wx.StaticText(part1, -1, u'Total Vendido em Dinheiro', pos=(310, 97))
wx.StaticText(part1,
-1,
u'Dia da Semana menos Rentável',
pos=(310, 137))
wx.StaticText(part1,
-1,
u'Dia da Semana mais Rentável',
pos=(310, 177))
wx.StaticText(part1,
-1,
u'Quantidade de Entradas Pendentes',
pos=(310, 217))
wx.StaticText(part1,
-1,
u'Quantidade de Gastos Pendentes',
pos=(310, 257))
wx.StaticText(part1, -1, u'Produtos de Maior Redimento',
pos=(625, 10)).SetFont(
wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
wx.StaticText(part1, -1, u'Produtos Mais Vendidos',
pos=(900, 10)).SetFont(
wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
part2 = wx.Panel(self,
-1,
pos=(10, 305),
size=(1180, 50),
style=wx.TAB_TRAVERSAL)
part21 = wx.Panel(part2,
-1,
pos=(10, 0),
size=(620, 50),
style=wx.SIMPLE_BORDER)
part22 = wx.Panel(part2,
-1,
pos=(790, 0),
size=(380, 50),
style=wx.SIMPLE_BORDER)
button1 = GenBitmapTextButton(
part21,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Report.png',
wx.BITMAP_TYPE_PNG),
u'Tabela de Vendas',
pos=(0, 0),
size=(150, 50))
button2 = GenBitmapTextButton(
part21,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Report.png',
wx.BITMAP_TYPE_PNG),
u'Tabela de Gastos',
pos=(150, 0),
size=(150, 50))
button3 = GenBitmapTextButton(
part21,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Report.png',
wx.BITMAP_TYPE_PNG),
u'Tabela de Produtos',
pos=(300, 0),
size=(150, 50))
button7 = GenBitmapTextButton(
part21,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Report.png',
wx.BITMAP_TYPE_PNG),
u'Tabela de Desperdícios',
pos=(450, 0),
size=(170, 50))
button8 = GenBitmapTextButton(
part2,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Reset.png',
wx.BITMAP_TYPE_PNG),
u'Recalcular',
pos=(645, 0),
size=(130, 50),
style=wx.SIMPLE_BORDER)
button4 = GenBitmapTextButton(
part22,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'system-users.png',
wx.BITMAP_TYPE_PNG),
u'Registar Gasto',
pos=(0, 0),
size=(130, 50))
button5 = GenBitmapTextButton(
part22,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'system-users.png',
wx.BITMAP_TYPE_PNG),
u'Registrar Ganho',
pos=(130, 0),
size=(130, 50))
button6 = GenBitmapTextButton(
part22,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'system-users.png',
wx.BITMAP_TYPE_PNG),
u'Observações',
pos=(260, 0),
size=(120, 50))
button1.Bind(wx.EVT_BUTTON, self.open_sheets_sales)
button2.Bind(wx.EVT_BUTTON, self.open_sheets_expenses)
button3.Bind(wx.EVT_BUTTON, self.open_sheets_products)
button7.Bind(wx.EVT_BUTTON, self.open_sheets_wastes)
button8.Bind(wx.EVT_BUTTON, self.setup)
button4.Bind(wx.EVT_BUTTON, self.open_new_monthly_expense)
button5.Bind(wx.EVT_BUTTON, self.open_new_monthly_income)
button6.Bind(wx.EVT_BUTTON, self.open_text_box)
button1.SetBackgroundColour(core.COLOR_LIGHT_YELLOW)
button2.SetBackgroundColour(core.COLOR_LIGHT_YELLOW)
button3.SetBackgroundColour(core.COLOR_LIGHT_YELLOW)
button7.SetBackgroundColour(core.COLOR_LIGHT_YELLOW)
button4.SetBackgroundColour(core.COLOR_LIGHT_BLUE)
button5.SetBackgroundColour(core.COLOR_LIGHT_BLUE)
button6.SetBackgroundColour(core.COLOR_LIGHT_BLUE)
part3 = wx.Panel(self,
pos=(10, 360),
size=(1180, 280),
style=wx.SIMPLE_BORDER)
part31 = wx.Panel(part3,
56,
pos=(10, 5),
size=(575, 260),
style=wx.SUNKEN_BORDER)
part31.SetBackgroundColour(core.COLOR_DEFAULT_BACKGROUND)
self.list_incomes = wx.gizmos.TreeListCtrl(part31,
-1,
pos=(10, 10),
size=(400, 240),
style=wx.SIMPLE_BORDER
| wx.TR_DEFAULT_STYLE
| wx.TR_FULL_ROW_HIGHLIGHT)
self.list_incomes.AddColumn(u"Data", width=110)
self.list_incomes.AddColumn(u"Descrição", width=180)
self.list_incomes.AddColumn(u"Valor", width=100)
self.list_incomes.SetMainColumn(0)
dr = wx.StaticText(part31, -1, u'Ganhos\nMensais', pos=(420, 10))
dr.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
last_panel = wx.Panel(part31,
pos=(420, 80),
size=(145, 160),
style=wx.SIMPLE_BORDER)
button31 = GenBitmapTextButton(
last_panel,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Add.png',
wx.BITMAP_TYPE_PNG),
u'Adicionar',
pos=(0, 0),
size=(145, 40))
button32 = GenBitmapTextButton(
last_panel,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Edit.png',
wx.BITMAP_TYPE_PNG),
u'Editar',
pos=(0, 40),
size=(145, 40))
button33 = GenBitmapTextButton(
last_panel,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Trash.png',
wx.BITMAP_TYPE_PNG),
u'Apagar',
pos=(0, 80),
size=(145, 40))
button34 = GenBitmapTextButton(
last_panel,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Reset.png',
wx.BITMAP_TYPE_PNG),
u'Atualizar',
pos=(0, 120),
size=(145, 40))
button31.Bind(wx.EVT_BUTTON, self.open_new_monthly_income)
button32.Bind(wx.EVT_BUTTON, self.open_edit_monthly_income)
button33.Bind(wx.EVT_BUTTON, self.ask_delete_income)
button34.Bind(wx.EVT_BUTTON, self.setup_monthly_incomes)
part32 = wx.Panel(part3,
56,
pos=(590, 5),
size=(575, 260),
style=wx.SUNKEN_BORDER)
part32.SetBackgroundColour(core.COLOR_DEFAULT_BACKGROUND)
self.list_expenses = wx.gizmos.TreeListCtrl(part32,
-1,
pos=(10, 10),
size=(400, 240),
style=wx.SIMPLE_BORDER
| wx.TR_DEFAULT_STYLE
| wx.TR_FULL_ROW_HIGHLIGHT)
self.list_expenses.AddColumn(u"Data", width=110)
self.list_expenses.AddColumn(u"Descrição", width=180)
self.list_expenses.AddColumn(u"Valor", width=100)
self.list_expenses.SetMainColumn(0)
dr = wx.StaticText(part32, -1, u'Gastos\nMensais', pos=(420, 10))
dr.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
last_buttons = wx.Panel(part32,
pos=(420, 80),
size=(145, 160),
style=wx.SIMPLE_BORDER)
button41 = GenBitmapTextButton(
last_buttons,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Add.png',
wx.BITMAP_TYPE_PNG),
u'Adicionar',
pos=(0, 0),
size=(145, 40))
button42 = GenBitmapTextButton(
last_buttons,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Edit.png',
wx.BITMAP_TYPE_PNG),
u'Editar',
pos=(0, 40),
size=(145, 40))
button43 = GenBitmapTextButton(
last_buttons,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Trash.png',
wx.BITMAP_TYPE_PNG),
u'Apagar',
pos=(0, 80),
size=(145, 40))
button44 = GenBitmapTextButton(
last_buttons,
-1,
wx.Bitmap(core.directory_paths['icons'] + 'Reset.png',
wx.BITMAP_TYPE_PNG),
u'Atualizar',
pos=(0, 120),
size=(145, 40))
button41.Bind(wx.EVT_BUTTON, self.open_new_monthly_expense)
button42.Bind(wx.EVT_BUTTON, self.open_edit_monthly_expense)
button43.Bind(wx.EVT_BUTTON, self.ask_delete_expense)
button44.Bind(wx.EVT_BUTTON, self.setup_monthly_expenses)
db = database.TransactionsDB()
dates = db.list_record_dates(transactions=True)
db.close()
month_options = list()
for date in dates:
date_ = core.format_date_user(date[:7])
if date_ not in month_options:
month_options.append(date_)
self.combobox_month_displayed = wx.ComboBox(part1,
-1,
choices=month_options,
size=(100, 30),
pos=(200, 15),
style=wx.CB_READONLY)
self.combobox_month_displayed.Bind(wx.EVT_COMBOBOX, self.setup)
if len(month_options) != 0:
self.combobox_month_displayed.SetValue(month_options[0])
def database_insert(self):
db = database.TransactionsDB()
db.insert_waste(self)
db.close()
def setup_selection_2(self):
month_user = self.combobox_month_option.GetValue()
date = core.format_date_internal(month_user)
if not month_user:
month_user = u"---------"
main_root = self.list_edited_data.AddRoot(month_user)
self.list_edited_data.SetItemText(main_root, u"Registros Apagados", 2)
db = database.TransactionsDB()
transactions = db.monthly_transactions_list(date, deleted=True)
categories = db.categories_list(deleted=True)
db.close()
incomes_counter = 0
expenses_counter = 0
categories_counter = len(categories)
expenses_value = 0.0
expenses_root = self.list_edited_data.AppendItem(
main_root, u"---------")
self.list_edited_data.SetItemText(expenses_root, u"Gastos", 2)
self.list_edited_data.SetItemText(expenses_root, str(expenses_counter),
3)
self.list_edited_data.SetItemFont(
expenses_root, wx.Font(11, wx.SWISS, wx.NORMAL, wx.BOLD))
incomes_value = 0.0
income_root = self.list_edited_data.AppendItem(main_root, u"---------")
self.list_edited_data.SetItemText(income_root, u"Entrada", 2)
self.list_edited_data.SetItemText(income_root, str(expenses_counter),
3)
self.list_edited_data.SetItemFont(
income_root, wx.Font(11, wx.SWISS, wx.NORMAL, wx.BOLD))
for data in transactions:
if data.type == data_types.EXPENSE:
parent = expenses_root
expenses_counter += 1
expenses_value += data.value
elif data.type == data_types.INCOME:
parent = income_root
incomes_counter += 1
incomes_value += data.value
else:
parent = main_root
item = self.list_edited_data.AppendItem(parent,
data.transaction_date)
self.list_edited_data.SetItemFont(
item, wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
self.list_edited_data.SetItemText(item,
core.format_id_user(data.ID), 1)
self.list_edited_data.SetItemText(item, data.description, 2)
self.list_edited_data.SetItemText(
item, core.format_cash_user(data.value, currency=True), 4)
self.list_edited_data.SetItemData(item, wx.TreeItemData(data))
self.list_edited_data.SetItemText(
income_root, core.format_cash_user(incomes_value, currency=True),
4)
self.list_edited_data.SetItemText(
expenses_root, core.format_cash_user(expenses_value,
currency=True), 4)
categories_root = self.list_edited_data.AppendItem(
main_root, u"---------")
self.list_edited_data.SetItemText(categories_root, u"Categorias", 2)
self.list_edited_data.SetItemText(categories_root,
str(categories_counter), 3)
self.list_edited_data.SetItemFont(
categories_root, wx.Font(11, wx.SWISS, wx.NORMAL, wx.BOLD))
for data in categories:
item = self.list_edited_data.AppendItem(categories_root,
u"---------")
self.list_edited_data.SetItemFont(
item, wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
self.list_edited_data.SetItemText(item,
core.format_id_user(data.ID), 1)
self.list_edited_data.SetItemText(item, data.category, 2)
self.list_edited_data.SetItemData(item, wx.TreeItemData(data))
self.list_edited_data.SetItemText(
main_root, str(incomes_counter + expenses_counter), 3)
self.list_edited_data.Expand(main_root)
self.list_edited_data.SetItemFont(
main_root, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
def setup_selection_0(self):
date_user = self.combobox_day_option.GetValue()
date = core.format_date_internal(date_user)
if not date_user:
date_user = u"---------"
main_root = self.list_edited_data.AddRoot(date_user)
self.list_edited_data.SetItemText(main_root, u"Registros Apagados", 2)
db = database.TransactionsDB()
sales = db.daily_sales_list(date, deleted=True)
expenses = db.daily_expenses_list(date, deleted=True)
wastes = db.daily_wastes_list(date, deleted=True)
db.close()
sales_counter = len(sales)
expenses_counter = len(expenses)
wastes_counter = len(wastes)
value = 0.0
sales_root = self.list_edited_data.AppendItem(main_root, u"---------")
self.list_edited_data.SetItemText(sales_root, u"Vendas", 2)
self.list_edited_data.SetItemText(sales_root, str(sales_counter), 3)
self.list_edited_data.SetItemFont(
sales_root, wx.Font(11, wx.SWISS, wx.NORMAL, wx.BOLD))
for data in sales:
value += data.value
item = self.list_edited_data.AppendItem(sales_root,
data.record_time)
self.list_edited_data.SetItemFont(
item, wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
self.list_edited_data.SetItemText(item,
core.format_id_user(data.ID), 1)
self.list_edited_data.SetItemText(item,
str(len(data.products_IDs)), 3)
self.list_edited_data.SetItemText(
item, core.format_cash_user(data.value, currency=True), 4)
self.list_edited_data.SetItemData(item, wx.TreeItemData(data))
for i in range(len(data.products_IDs)):
price = data.amounts[i] * data.prices[i]
product = self.list_edited_data.AppendItem(item, u"---------")
self.list_edited_data.SetItemText(
product, core.format_id_user(data.products_IDs[i]), 1)
self.list_edited_data.SetItemText(
product, core.format_amount_user(data.amounts[i]), 3)
self.list_edited_data.SetItemText(
product, core.format_cash_user(price, currency=True), 4)
if data.discount != 0:
extra = self.list_edited_data.AppendItem(item, u"---------")
self.list_edited_data.SetItemText(extra, u'Desconto', 2)
self.list_edited_data.SetItemText(
extra, core.format_cash_user(data.discount, currency=True),
4)
if data.taxes != 0:
extra = self.list_edited_data.AppendItem(item, u"---------")
self.list_edited_data.SetItemText(extra, u'Taixas adicionais',
2)
self.list_edited_data.SetItemText(
extra, core.format_cash_user(data.discount, currency=True),
4)
self.list_edited_data.SetItemText(
sales_root, core.format_cash_user(value, currency=True), 4)
value = 0.0
expenses_root = self.list_edited_data.AppendItem(
main_root, u"---------")
self.list_edited_data.SetItemText(expenses_root, u"Gastos", 2)
self.list_edited_data.SetItemText(expenses_root, str(expenses_counter),
3)
self.list_edited_data.SetItemFont(
expenses_root, wx.Font(11, wx.SWISS, wx.NORMAL, wx.BOLD))
for data in expenses:
value += data.value
item = self.list_edited_data.AppendItem(expenses_root,
data.record_time)
self.list_edited_data.SetItemFont(
item, wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
self.list_edited_data.SetItemText(item,
core.format_id_user(data.ID), 1)
self.list_edited_data.SetItemText(item, data.description, 2)
self.list_edited_data.SetItemText(
item, core.format_cash_user(data.value, currency=True), 4)
self.list_edited_data.SetItemData(item, wx.TreeItemData(data))
self.list_edited_data.SetItemText(
expenses_root, core.format_cash_user(value, currency=True), 4)
wastes_root = self.list_edited_data.AppendItem(main_root, u"---------")
self.list_edited_data.SetItemText(wastes_root, u"Desperdícios", 2)
self.list_edited_data.SetItemText(wastes_root, str(expenses_counter),
3)
self.list_edited_data.SetItemFont(
wastes_root, wx.Font(11, wx.SWISS, wx.NORMAL, wx.BOLD))
for data in wastes:
item = self.list_edited_data.AppendItem(wastes_root,
data.record_time)
self.list_edited_data.SetItemFont(
item, wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
self.list_edited_data.SetItemText(item,
core.format_id_user(data.ID), 1)
self.list_edited_data.SetItemText(
item, core.format_id_user(data.product_ID), 2)
self.list_edited_data.SetItemText(
item, core.format_amount_user(data.amount), 3)
self.list_edited_data.SetItemData(item, wx.TreeItemData(data))
self.list_edited_data.SetItemText(
main_root, str(sales_counter + wastes_counter + expenses_counter),
3)
self.list_edited_data.Expand(main_root)
self.list_edited_data.SetItemFont(
main_root, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
def setup_incomes(self):
sales_db = database.TransactionsDB()
sales = sales_db.monthly_sales_list(self.month)
incomes = sales_db.monthly_transactions_list(self.month,
transaction.INCOME)
sales_db.close()
self.AddColumn(u'Data/Horário', 250)
self.AddColumn(u'Pagamento', 150)
self.AddColumn(u'Descrição', 250)
self.AddColumn(u'Quantidade', 100)
self.AddColumn(u'Valor', 150)
root = self.AddRoot(u'Ganhos de %s' %
core.date_reverse(self.month).replace('-', '/'))
self.SetItemFont(root, wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
a = 0.0
b = 0
days = {}
saturdays = core.week_end(self.month)
weeks = {}
for sale_ in sales:
for day in saturdays:
if day >= int(sale_.record_date.split('-')[2]):
week = saturdays.index(day) + 1
break
if week not in weeks:
we = self.AppendItem(root, u'%iª Semana' % week)
self.SetItemFont(we, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
weeks[week] = [we, 0.0, 0]
if sale_.record_date not in days:
item = self.AppendItem(
weeks[week][0], core.format_date_user(sale_.record_date))
self.SetItemFont(item, wx.Font(11, wx.SWISS, wx.NORMAL,
wx.BOLD))
days[sale_.record_date] = [item, 0.0, 0]
b += 1
a += sale_.value
weeks[week][1] += sale_.value
weeks[week][2] += 1
days[sale_.record_date][1] += sale_.value
days[sale_.record_date][2] += 1
father = self.AppendItem(days[sale_.record_date][0],
sale_.record_time)
self.SetItemFont(father, wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
self.SetItemText(father, sale_.payment, 1)
self.SetItemText(father, u'-----------', 2)
self.SetItemText(father, str(len(sale_.products_IDs)), 3)
self.SetItemText(father,
core.format_cash_user(sale_.value, currency=True),
4)
self.SetItemData(father, wx.TreeItemData(sale_))
for i in range(len(sale_.products_IDs)):
kid = self.AppendItem(father, u'-----------')
self.SetItemText(kid, u'-----------', 1)
self.SetItemText(kid,
core.format_id_user(sale_.products_IDs[i]), 2)
self.SetItemText(kid,
core.format_amount_user(sale_.amounts[i]), 3)
self.SetItemText(
kid, core.format_cash_user(sale_.prices[i], currency=True),
4)
self.SetItemData(kid,
wx.TreeItemData(str(sale_.products_IDs[i])))
for j in weeks:
self.SetItemText(weeks[j][0], str(weeks[j][2]), 3)
self.SetItemText(weeks[j][0],
core.format_cash_user(weeks[j][1], currency=True),
4)
for j in days:
self.SetItemText(days[j][0], str(days[j][2]), 3)
self.SetItemText(days[j][0],
core.format_cash_user(days[j][1], currency=True),
4)
self.SortChildren(days[j][0])
if len(incomes):
parent = self.AppendItem(root, u'Outras entradas de dinheiro')
self.SetItemFont(parent, wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
for income in incomes:
b += 1
a += income.value
payment = u'RECEBIDO'
payment = payment if not income.payment_pendant else u'AINDA NÃO ' + payment
father = self.AppendItem(
parent, core.format_date_user(income.transaction_date))
self.SetItemFont(father,
wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
self.SetItemText(father, payment, 1)
self.SetItemText(father, income.description, 2)
self.SetItemText(
father, core.format_cash_user(income.value, currency=True),
4)
self.SetItemData(father, wx.TreeItemData(income))
self.SetItemText(root, str(b), 3)
self.SetItemText(root, core.format_cash_user(a, currency=True), 4)
self.Expand(root)
self.SortChildren(root)
def ready(self, event):
db = database.TransactionsDB()
db.edit_transaction_payment(self.data.ID)
db.close()
self.exit(None)
