def search_for_date(self, date):
dfilter = DateSearchFilter(_("Expected receival date"))
dfilter.set_removable()
dfilter.mode.select_item_by_position(5)
self.add_filter(dfilter, columns=["expected_receival_date"])
dfilter.start_date.set_date(date)
self.search.refresh()
def search_for_date(self, date):
self.main_filter.select(None)
dfilter = DateSearchFilter(_("Paid or due date"))
dfilter.set_removable()
dfilter.mode.select_item_by_position(5)
self.add_filter(dfilter, columns=["paid_date", "due_date"])
dfilter.start_date.set_date(date)
self.search.refresh()
class PaymentFlowHistoryDialog(BasicDialog):
title = _(u'Payment Flow History Dialog')
desc = _("Select a date or a range to be visualised in the report:")
size = (-1, -1)
model_type = PaymentFlowDay
def __init__(self, store):
"""A dialog to print the PaymentFlowHistoryReport report.
:param store: a store
"""
self.store = store
BasicDialog.__init__(self, header_text='<b>%s</b>' % self.desc,
title=self.title)
self._setup_widgets()
#
# BasicDialog
#
def confirm(self):
state = self._date_filter.get_state()
from kiwi.db.query import DateQueryState
if isinstance(state, DateQueryState):
start, end = state.date, state.date
else:
start, end = state.start, state.end
results = PaymentFlowDay.get_flow_history(self.store, start, end)
if not results:
info(_('No payment history found.'))
return False
print_report(PaymentFlowHistoryReport, payment_histories=results)
return True
#
# Private
#
def _setup_widgets(self):
self.ok_button.set_label(gtk.STOCK_PRINT)
self._date_filter = DateSearchFilter(_(u'Date:'))
#FIXME: add a remove_option method in DateSearchFilter.
self._date_filter.clear_options()
self._date_filter.add_custom_options()
for option in [Today, Yesterday, LastWeek, LastMonth]:
self._date_filter.add_option(option)
self._date_filter.select(position=0)
self.vbox.pack_start(self._date_filter, False, False)
self._date_filter.show_all()
def create_filters(self):
self.set_text_field_columns(['description'])
self.executer.set_query(self.executer_query)
# Date
date_filter = DateSearchFilter(_('Date:'))
date_filter.select(0)
columns = [Payment.due_date,
Payment.open_date,
Payment.paid_date]
self.add_filter(date_filter, columns=columns)
self.date_filter = date_filter
def create_filters(self):
self.set_text_field_columns(['description'])
self.executer.set_query(self.executer_query)
# Date
date_filter = DateSearchFilter(_('Date:'))
date_filter.select(Today)
self.add_filter(date_filter)
self.date_filter = date_filter
# Branch
branch_filter = self.create_branch_filter(_('In branch:'))
branch_filter.select(None)
self.add_filter(branch_filter, columns=[],
position=SearchFilterPosition.TOP)
self.branch_filter = branch_filter
def create_filters(self):
self.set_text_field_columns(['description'])
# Date
date_filter = DateSearchFilter(_('Date:'))
date_filter.select(Today)
columns = [ProductHistory.sold_date,
ProductHistory.received_date,
ProductHistory.production_date,
ProductHistory.decreased_date]
self.add_filter(date_filter, columns=columns)
self.date_filter = date_filter
# Branch
self.branch_filter = self.create_branch_filter(_('In branch:'))
self.add_filter(self.branch_filter, columns=['branch'],
position=SearchFilterPosition.TOP)
# remove 'Any' option from branch_filter
self.branch_filter.combo.remove_text(0)
def create_filters(self):
self.set_text_field_columns(['description'])
self.date_filter = DateSearchFilter(_('Date:'))
self.date_filter.select(Today)
self.add_filter(self.date_filter, columns=['date'])
# add summary label
value_format = '<b>%s</b>'
total_label = '<b>%s</b>' % api.escape(_(u'Total:'))
self.search.set_summary_label('value', total_label, value_format)
def _setup_widgets(self):
self.ok_button.set_label(gtk.STOCK_PRINT)
self._date_filter = DateSearchFilter(_(u'Date:'))
#FIXME: add a remove_option method in DateSearchFilter.
self._date_filter.clear_options()
self._date_filter.add_custom_options()
for option in [Today, Yesterday, LastWeek, LastMonth]:
self._date_filter.add_option(option)
self._date_filter.select(position=0)
self.vbox.pack_start(self._date_filter, False, False)
self._date_filter.show_all()
def __init__(self, store):
self.store = store
self.date_filter = DateSearchFilter(_('Year:'))
self.date_filter.clear_options()
self._populate_date_filter(self.date_filter)
self.date_filter.select()
self.date_filter.set_use_date_entries(False)
BasicDialog.__init__(self, title=self.title)
self.justify_label(gtk.JUSTIFY_CENTER)
self.ok_button.set_label(_("Generate"))
self.add(self.date_filter)
self.date_filter.show()
class SintegraDialog(BasicDialog):
title = _('Fiscal Printer History')
def __init__(self, store):
BasicDialog.__init__(self, title=self.title)
self.justify_label(gtk.JUSTIFY_CENTER)
self.store = store
self.ok_button.set_label(_("Generate"))
self.date_filter = DateSearchFilter(_('Month:'))
self.date_filter.set_use_date_entries(False)
self.date_filter.clear_options()
self._populate_date_filter(self.date_filter)
self.date_filter.select()
self.add(self.date_filter)
self.date_filter.show()
def confirm(self):
start = self.date_filter.get_start_date()
end = self.date_filter.get_end_date()
filename = save(_("Save Sintegra file"),
self.get_toplevel(),
"sintegra-%s.txt" % (start.strftime('%Y-%m'), ))
if not filename:
return
try:
generator = StoqlibSintegraGenerator(self.store, start, end)
generator.write(filename)
except SintegraError, e:
warning(str(e))
return
self.close()
def _add_date_filter(self):
self.date_filter = DateSearchFilter(_('Date:'))
self.date_filter.clear_options()
self.date_filter.add_option(Any, 0)
year = datetime.datetime.today().year
month_names = get_month_names()
for i, month in enumerate(month_names):
name = month_names[i]
option = type(name + 'Option', (MonthOption, ),
{'name': _(name),
'month': i + 1,
'year': year})
self.date_filter.add_option(option, i + 1)
self.date_filter.add_custom_options()
self.date_filter.mode.select_item_by_position(0)
self.search.add_filter(self.date_filter)
class TillHistoryDialog(SearchDialog):
size = (780, -1)
table = TillEntry
selection_mode = gtk.SELECTION_MULTIPLE
searchbar_labels = _('Till Entries matching:')
title = _('Till history')
#
# SearchDialog
#
def get_columns(self, *args):
return [Column('identifier', _('Number'), data_type=int, width=100,
format='%03d', sorted=True),
Column('date', _('Date'), data_type=datetime.date),
Column('time', _('Time'), data_type=datetime.time),
Column('description', _('Description'), data_type=str,
expand=True),
ColoredColumn('value', _('Value'), data_type=currency,
color='red', data_func=payment_value_colorize,
width=140)]
def create_filters(self):
self.set_text_field_columns(['description'])
self.date_filter = DateSearchFilter(_('Date:'))
self.date_filter.select(Today)
self.add_filter(self.date_filter, columns=['date'])
# add summary label
value_format = '<b>%s</b>'
total_label = '<b>%s</b>' % api.escape(_(u'Total:'))
self.search.set_summary_label('value', total_label, value_format)
def setup_widgets(self):
self.results.set_visible_rows(10)
self.results.connect('has-rows', self._has_rows)
self._add_editor_button(_('Cash _Add...'), CashAdvanceEditor,
STOQ_MONEY)
self._add_editor_button(_('Cash _In...'), CashInEditor,
STOQ_MONEY_ADD)
self._add_editor_button(_('Cash _Out...'), CashOutEditor,
STOQ_MONEY_REMOVE)
self.print_button = gtk.Button(None, gtk.STOCK_PRINT, True)
self.print_button.set_property("use-stock", True)
self.print_button.connect('clicked', self._print_button_clicked)
self.action_area.set_layout(gtk.BUTTONBOX_START)
self.action_area.pack_end(self.print_button, False, False, 6)
self.print_button.show()
self.print_button.set_sensitive(False)
#
# Private API
#
def _add_editor_button(self, name, editor_class, stock):
button = self.add_button(name, stock=stock)
button.connect('clicked', self._run_editor, editor_class)
button.show()
def _print_button_clicked(self, button):
till_entries = self.results.get_selected_rows() or list(self.results)
print_report(TillHistoryReport, self.results, till_entries,
filters=self.search.get_search_filters())
def _run_editor(self, button, editor_class):
with api.trans() as store:
run_dialog(editor_class, self, store)
if store.committed:
self.search.refresh()
self.results.unselect_all()
if len(self.results):
self.results.select(self.results[-1])
def _has_rows(self, results, obj):
self.print_button.set_sensitive(obj)
class FinancialReportDialog(BasicDialog):
title = _('Financial Report Dialog')
def __init__(self, store):
self.store = store
self.date_filter = DateSearchFilter(_('Year:'))
self.date_filter.clear_options()
self._populate_date_filter(self.date_filter)
self.date_filter.select()
self.date_filter.set_use_date_entries(False)
BasicDialog.__init__(self, title=self.title)
self.justify_label(gtk.JUSTIFY_CENTER)
self.ok_button.set_label(_("Generate"))
self.add(self.date_filter)
self.date_filter.show()
def confirm(self):
start = self.date_filter.get_start_date()
if start is None:
warning(_("There are no transactions yet"))
return
f = FinancialIntervalReport(self.store, start.year)
if not f.run():
return
temporary = tempfile.NamedTemporaryFile(
# Translators: This will be part of a filename
prefix=_('stoq-yearly-report'),
suffix='.xls', delete=False)
f.write(temporary)
sse = SpreadSheetExporter()
sse.export_temporary(temporary)
self.close()
#
# Private
#
def _populate_date_filter(self, date_filter):
transaction = self.store.find(AccountTransaction).order_by(
AccountTransaction.date).first()
if transaction is None:
return
for i in range(transaction.date.year,
datetime.date.today().year + 1):
year = datetime.datetime(i, 1, 1)
date_filter.add_option_fixed_interval(
_('Year %d') % (i, ),
year, year.replace(month=12, day=31),
position=0)
def _date_filter_query(self, search_table, column):
executer = StoqlibQueryExecuter(self.store)
executer.set_filter_columns(self.date_filter, [column])
executer.set_table(search_table)
return executer.search([self.date_filter.get_state()])
class TransactionPage(object):
# shows either a list of:
# - transactions
# - payments
def __init__(self, model, app, parent):
self.model = model
self.app = app
self.parent_window = parent
self._block = False
self._create_search()
self._add_date_filter()
self._setup_search()
self.refresh()
def get_toplevel(self):
return self.parent_window
def _create_search(self):
self.search = TransactionSearchContainer(
self, columns=self._get_columns(self.model.kind))
self.query = StoqlibQueryExecuter(self.app.store)
self.search.set_query_executer(self.query)
self.search.results.connect('row-activated', self._on_row__activated)
self.results = self.search.results
tree_view = self.search.results.get_treeview()
tree_view.set_rules_hint(True)
tree_view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
self.search.enable_advanced_search()
def _add_date_filter(self):
self.date_filter = DateSearchFilter(_('Date:'))
self.date_filter.clear_options()
self.date_filter.add_option(Any, 0)
year = datetime.datetime.today().year
month_names = get_month_names()
for i, month in enumerate(month_names):
name = month_names[i]
option = type(name + 'Option', (MonthOption, ),
{'name': _(name),
'month': i + 1,
'year': year})
self.date_filter.add_option(option, i + 1)
self.date_filter.add_custom_options()
self.date_filter.mode.select_item_by_position(0)
self.search.add_filter(self.date_filter)
def _append_date_query(self, field):
date = self.date_filter.get_state()
queries = []
if isinstance(date, DateQueryState) and date.date is not None:
queries.append(Date(field) == date.date)
elif isinstance(date, DateIntervalQueryState):
queries.append(Date(field) >= date.start)
queries.append(Date(field) <= date.end)
return queries
def _payment_query(self, store):
queries = self._append_date_query(self.query.table.due_date)
if queries:
return store.find(self.query.table, And(*queries))
return store.find(self.query.table)
def _transaction_query(self, store):
queries = [Or(self.model.id == AccountTransaction.account_id,
self.model.id == AccountTransaction.source_account_id)]
queries.extend(self._append_date_query(AccountTransaction.date))
return store.find(AccountTransactionView, And(*queries))
def show(self):
self.search.show()
def _setup_search(self):
if self.model.kind == 'account':
self.query.set_table(AccountTransactionView)
self.search.set_text_field_columns(['description'])
self.query.set_query(self._transaction_query)
elif self.model.kind == 'payable':
self.search.set_text_field_columns(['description', 'supplier_name'])
self.query.set_table(OutPaymentView)
self.query.set_query(self._payment_query)
elif self.model.kind == 'receivable':
self.search.set_text_field_columns(['description', 'drawee'])
self.query.set_table(InPaymentView)
self.query.set_query(self._payment_query)
else:
raise TypeError("unknown model kind: %r" % (self.model.kind, ))
def refresh(self):
self.search.results.clear()
if self.model.kind == 'account':
transactions = AccountTransactionView.get_for_account(self.model, self.app.store)
self.append_transactions(transactions)
elif self.model.kind == 'payable':
self._populate_payable_payments(OutPaymentView)
elif self.model.kind == 'receivable':
self._populate_payable_payments(InPaymentView)
else:
raise TypeError("unknown model kind: %r" % (self.model.kind, ))
def _get_columns(self, kind):
if kind in ['payable', 'receivable']:
return self._get_payment_columns()
else:
return self._get_account_columns()
def _get_account_columns(self):
def format_withdrawal(value):
if value < 0:
return currency(abs(value)).format(symbol=True, precision=2)
def format_deposit(value):
if value > 0:
return currency(value).format(symbol=True, precision=2)
if self.model.account_type == Account.TYPE_INCOME:
color_func = lambda x: False
else:
color_func = lambda x: x < 0
return [Column('date', title=_("Date"), data_type=datetime.date, sorted=True),
Column('code', title=_("Code"), data_type=unicode),
Column('description', title=_("Description"),
data_type=unicode, expand=True),
Column('account', title=_("Account"), data_type=unicode),
Column('value',
title=self.model.account.get_type_label(out=False),
data_type=currency,
format_func=format_deposit),
Column('value',
title=self.model.account.get_type_label(out=True),
data_type=currency,
format_func=format_withdrawal),
ColoredColumn('total', title=_("Total"), data_type=currency,
color='red',
data_func=color_func)]
def _get_payment_columns(self):
return [SearchColumn('due_date', title=_("Due date"), data_type=datetime.date, sorted=True),
SearchColumn('identifier', title=_("Code"), data_type=int),
SearchColumn('description', title=_("Description"), data_type=unicode, expand=True),
SearchColumn('value', title=_("Value"),
data_type=currency)]
def append_transactions(self, transactions):
for transaction in transactions:
description = transaction.get_account_description(self.model)
value = transaction.get_value(self.model)
self._add_transaction(transaction, description, value)
self.update_totals()
def _populate_payable_payments(self, view_class):
for view in self.app.store.find(view_class):
self.search.results.append(view)
def _add_transaction(self, transaction, description, value):
item = Settable(transaction=transaction)
self._update_transaction(item, transaction, description, value)
self.search.results.append(item)
return item
def _update_transaction(self, item, transaction, description, value):
item.account = description
item.date = transaction.date
item.description = transaction.description
item.value = value
item.code = transaction.code
def update_totals(self):
total = decimal.Decimal('0')
for item in self.search.results:
total += item.value
item.total = total
def _edit_transaction_dialog(self, item):
store = api.new_store()
if isinstance(item.transaction, AccountTransactionView):
account_transaction = store.fetch(item.transaction.transaction)
else:
account_transaction = store.fetch(item.transaction)
model = getattr(self.model, 'account', self.model)
transaction = run_dialog(AccountTransactionEditor, self.app,
store, account_transaction, model)
if transaction:
store.flush()
self._update_transaction(item, transaction,
transaction.edited_account.description,
transaction.value)
self.update_totals()
self.search.results.update(item)
self.app.accounts.refresh_accounts(self.app.store)
store.confirm(transaction)
store.close()
def on_dialog__opened(self, dialog):
dialog.connect('account-added', self.on_dialog__account_added)
def on_dialog__account_added(self, dialog):
self.app.accounts.refresh_accounts(self.app.store)
def add_transaction_dialog(self):
store = api.new_store()
model = getattr(self.model, 'account', self.model)
model = store.fetch(model)
transaction = run_dialog(AccountTransactionEditor, self.app,
store, None, model)
if transaction:
transaction.sync()
value = transaction.value
other = transaction.get_other_account(model)
if other == model:
value = -value
item = self._add_transaction(transaction, other.description, value)
self.update_totals()
self.search.results.update(item)
self.app.accounts.refresh_accounts(self.app.store)
store.confirm(transaction)
store.close()
def _on_row__activated(self, objectlist, item):
if self.model.kind == 'account':
self._edit_transaction_dialog(item)