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 = SearchSlave(self._get_columns(self.model.kind),
store=self.app.store)
self.search.connect('result-item-activated',
self._on_search__item_activated)
self.search.enable_advanced_search()
self.search.set_result_view(FinancialSearchResults)
self.result_view = self.search.result_view
self.result_view.page = self
tree_view = self.search.result_view.get_treeview()
tree_view.set_rules_hint(True)
tree_view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
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):
executer = self.search.get_query_executer()
search_spec = executer.search_spec
queries = self._append_date_query(search_spec.due_date)
if queries:
return store.find(search_spec, And(*queries))
return store.find(search_spec)
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.search.set_search_spec(AccountTransactionView)
self.search.set_text_field_columns(['description'])
self.search.set_query(self._transaction_query)
elif self.model.kind == 'payable':
self.search.set_text_field_columns(['description', 'supplier_name'])
self.search.set_search_spec(OutPaymentView)
self.search.set_query(self._payment_query)
elif self.model.kind == 'receivable':
self.search.set_text_field_columns(['description', 'drawee'])
self.search.set_search_spec(InPaymentView)
self.search.set_query(self._payment_query)
else:
raise TypeError("unknown model kind: %r" % (self.model.kind, ))
def refresh(self):
self.search.result_view.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),
IdentifierColumn('identifier', title=_("Code")),
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.result_view.append(view)
def _add_transaction(self, transaction, description, value):
item = Settable(transaction=transaction)
self._update_transaction(item, transaction, description, value)
self.search.result_view.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.result_view:
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.result_view.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.result_view.update(item)
self.app.accounts.refresh_accounts(self.app.store)
store.confirm(transaction)
store.close()
def _on_search__item_activated(self, objectlist, item):
if self.model.kind == 'account':
self._edit_transaction_dialog(item)
class ShellApp(GladeDelegate):
"""Base class for shell applications.
The main use is to interact with a shell window and reduce
duplication between other applications.
"""
#: This attribute is used when generating titles for applications.
#: It's also useful if we get a list of available applications with
#: the application names translated. This list is going to be used when
#: creating new user profiles.
app_title = None
#: name of the application, 'pos', 'payable', etc
app_name = None
#: If this application has a search like interface
search = None
#: This dictionary holds information about required permissions to access
#: certain actions. Keys should be the name of the action (for instance
#: SearchEmployess), and the value should be a tuple with the permission key
#: (domain object or action identifier) and the required permission. In this
#: case: ('Employee', perm.PERM_SEARCH). See <stoqlib.lib.permissions>
action_permissions = {}
#: The table we will query on to perform the search
search_table = None
#: Label left of the search entry
search_label = _('Search:')
#: the report class for printing the object list embedded on app.
report_table = None
def __init__(self, window, store=None):
if store is None:
store = api.get_default_store()
self.store = store
self.window = window
self._loading_filters = False
self._sensitive_group = dict()
self.help_ui = None
self.uimanager = self.window.uimanager
self._pre_init()
GladeDelegate.__init__(self,
gladefile=self.gladefile,
toplevel_name=self.toplevel_name)
self._post_init()
def _pre_init(self):
# FIXME: Perhaps we should add a proper API to add a search to
# an application, however it's a bit complicated since the
# search creation is done in two steps due to how kiwi auto
# signal connection works
if self.search_table is not None:
self._create_search()
self._app_settings = api.user_settings.get('app-ui', {})
# Create actions, this must be done before the constructor
# is called, eg when signals are autoconnected
self.create_actions()
def _post_init(self):
self.create_ui()
if self.search_table is not None:
self.attach_slave('search_holder', self.search)
self.create_filters()
self._restore_filter_settings()
self.search.focus_search_entry()
def _create_search(self):
# This does the first part of the search creation,
# this need to be done here so that self.results is set when we
# call GladeDelegate.__init__()
self.executer = QueryExecuter(self.store)
# FIXME: Remove this limit, but we need to migrate all existing
# searches to use lazy lists first. That in turn require
# us to rewrite the queries in such a way that count(*)
# will work properly.
self.executer.set_limit(sysparam(self.store).MAX_SEARCH_RESULTS)
self.executer.set_table(self.search_table)
self.search = SearchSlave(self.get_columns(),
restore_name=self.__class__.__name__)
self.search.enable_advanced_search()
self.search.set_query_executer(self.executer)
self.search.connect("search-completed",
self._on_search__search_completed)
self.results = self.search.result_view
search_filter = self.search.get_primary_filter()
search_filter.set_label(self.search_label)
def _display_open_inventory_message(self):
msg = _(u'There is an inventory process open at the moment.\n'
'While that inventory is open, you will be unable to do '
'operations that modify your stock.')
self.inventory_bar = self.window.add_info_bar(gtk.MESSAGE_WARNING, msg)
def _save_filter_settings(self):
if self._loading_filters:
return
filter_states = self.search.get_filter_states()
settings = self._app_settings.setdefault(self.app_name, {})
settings['filter-states'] = filter_states
def _restore_filter_settings(self):
self._loading_filters = True
settings = self._app_settings.setdefault(self.app_name, {})
filter_states = settings.get('filter-states')
if filter_states is not None:
# Disable auto search to avoid an extra query when restoring the
# state
self.search.set_auto_search(False)
self.search.set_filter_states(filter_states)
self.search.set_auto_search(True)
self._loading_filters = False
#
# Overridables
#
def create_actions(self):
"""This is called before the BaseWindow constructor, so we
can create actions that can be autoconnected.
The widgets and actions loaded from builder files are not set
yet"""
def create_ui(self):
"""This is called when the UI such as GtkWidgets should be
created. Glade widgets are now created and can be accessed
in the instance.
"""
def activate(self, params):
"""This is when you switch to an application.
You should setup widget sensitivity here and refresh lists etc
:params params: an dictionary with optional parameters.
"""
def setup_focus(self):
"""Define this method on child when it's needed.
This is for calling grab_focus(), it's called after the window
is shown. focus chains should be created in create_ui()"""
def get_title(self):
# This method must be redefined in child when it's needed
branch = api.get_current_branch(self.store)
return _('[%s] - %s') % (branch.get_description(), self.app_title)
def can_change_application(self):
"""Define if we can change the current application or not.
:returns: True if we can change the application, False otherwise.
"""
return True
def can_close_application(self):
"""Define if we can close the current application or not.
:returns: True if we can close the application, False otherwise.
"""
return True
def set_open_inventory(self):
""" Subclasses should overide this if they call
:obj:`.check_open_inventory`.
This method will be called it there is an open inventory, so the
application can disable some funcionalities
"""
raise NotImplementedError
def new_activate(self):
"""Called when the New toolbar item is activated"""
raise NotImplementedError
def search_activate(self):
"""Called when the Search toolbar item is activated"""
raise NotImplementedError
def print_activate(self):
"""Called when the Print toolbar item is activated"""
if self.search_table is None:
raise NotImplementedError
if self.results.get_selection_mode() == gtk.SELECTION_MULTIPLE:
results = self.results.get_selected_rows()
else:
result = self.results.get_selected()
results = [result] if result else None
# There are no itens selected. We should print the entire list
if not results:
results = list(self.search.get_last_results())
self.print_report(self.report_table, self.results, results)
def export_spreadsheet_activate(self):
"""Called when the Export menu item is activated"""
if self.search_table is None:
raise NotImplementedError
sse = SpreadSheetExporter()
sse.export(object_list=self.results,
name=self.app_name,
filename_prefix=self.app.name)
def create_filters(self):
"""Implement this to provide filters for the search container"""
def search_completed(self, results, states):
"""Implement this if you want to know when a search has
been completed.
:param results: the search results
:param states: search states used to construct the search query search
"""
#
# Public API
#
def add_ui_actions(self,
ui_string,
actions,
name='Actions',
action_type='normal',
filename=None):
return self.window.add_ui_actions(ui_string=ui_string,
actions=actions,
name=name,
action_type=action_type,
filename=filename,
instance=self)
def add_tool_menu_actions(self, actions):
return self.window.add_tool_menu_actions(actions=actions)
def set_help_section(self, label, section):
self.window.set_help_section(label=label, section=section)
def get_statusbar_message_area(self):
return self.window.statusbar.message_area
def print_report(self, report_class, *args, **kwargs):
filters = self.search.get_search_filters()
if filters:
kwargs['filters'] = filters
print_report(report_class, *args, **kwargs)
def set_sensitive(self, widgets, value):
"""Set the *widgets* sensitivity based on *value*
If a sensitive group was registered for any widget,
it's validation function will be tested and, if ``False``
is returned, it will be set insensitive, ignoring *value*
:param widgets: a list of widgets
:param value: either `True` or `False`
"""
# FIXME: Maybe this should ne done on kiwi?
for widget in widgets:
sensitive = value
for validator in self._sensitive_group.get(widget, []):
if not validator[0](*validator[1]):
sensitive = False
break
widget.set_sensitive(sensitive)
def register_sensitive_group(self, widgets, validation_func, *args):
"""Register widgets on a sensitive group.
Everytime :obj:`.set_sensitive()` is called, if there is any
validation function for a given widget on sensitive group,
then that will be used to decide if it gets sensitive or
insensitive.
:param widgets: a list of widgets
:param validation_func: a function for validation. It should
return either ``True`` or ``False``.
:param args: args that will be passed to *validation_func*
"""
assert callable(validation_func)
for widget in widgets:
validators = self._sensitive_group.setdefault(widget, set())
validators.add((validation_func, args))
def run_dialog(self, dialog_class, *args, **kwargs):
""" Encapsuled method for running dialogs. """
return run_dialog(dialog_class, self, *args, **kwargs)
@cached_function()
def has_open_inventory(self):
return Inventory.has_open(self.store,
api.get_current_branch(self.store))
def check_open_inventory(self):
"""Checks if there is an open inventory.
In the case there is one, will call set_open_inventory (subclasses
should implement it).
Returns True if there is an open inventory. False otherwise
"""
inventory_bar = getattr(self, 'inventory_bar', None)
if self.has_open_inventory():
if inventory_bar:
inventory_bar.show()
else:
self._display_open_inventory_message()
self.set_open_inventory()
return True
elif inventory_bar:
inventory_bar.hide()
return False
# FIXME: Most of these should be removed and access the search API
# directly, eg, self.search.clear() etc
def add_filter(self,
search_filter,
position=SearchFilterPosition.BOTTOM,
columns=None,
callback=None):
"""
See :class:`SearchSlave.add_filter`
"""
self.search.add_filter(search_filter, position, columns, callback)
def set_text_field_columns(self, columns):
"""
See :class:`SearchSlave.set_text_field_columns`
"""
self.search.set_text_field_columns(columns)
def refresh(self):
"""
See :class:`stoqlib.gui.search.searchslave.SearchSlave.refresh`
"""
self.search.refresh()
def clear(self):
"""
See :class:`stoqlib.gui.search.searchslave.SearchSlave.clear`
"""
self.search.clear()
def select_result(self, result):
"""Select the object in the result list
If the object is not in the list (filtered out, for instance), no error
is thrown and nothing is selected
"""
try:
self.results.select(result)
except ValueError:
pass
#
# Callbacks
#
def _on_search__search_completed(self, search, results, states):
self.search_completed(results, states)
has_results = len(results)
for widget in [self.window.Print, self.window.ExportSpreadSheet]:
widget.set_sensitive(has_results)
self._save_filter_settings()
