def thirdaddon_accounting(item, xfer):
if WrapAction.is_permission(xfer.request, 'accounting.change_entryaccount'):
try:
entry_lines_filter = Q(entrylineaccount__third=item)
lines_filter = xfer.getparam('lines_filter', 0)
if lines_filter == 0:
entry_lines_filter &= Q(year=FiscalYear.get_current())
elif lines_filter == 1:
entry_lines_filter &= Q(year=FiscalYear.get_current()) & Q(close=False)
xfer.new_tab(_('entry of account'))
lbl = XferCompLabelForm('lbl_lines_filter')
lbl.set_value_as_name(_('Accounts filter'))
lbl.set_location(0, 1)
xfer.add_component(lbl)
edt = XferCompSelect("lines_filter")
edt.set_select([(0, _('All entries of current fiscal year')), (1, _(
'Only no-closed entries of current fiscal year')), (2, _('All entries for all fiscal year'))])
edt.set_value(lines_filter)
edt.set_location(1, 1)
edt.set_action(xfer.request, xfer.get_action(),
modal=FORMTYPE_REFRESH, close=CLOSE_NO)
xfer.add_component(edt)
entries = EntryAccount.objects.filter(entry_lines_filter)
link_grid_lines = XferCompGrid('entryaccount')
link_grid_lines.set_model(entries, EntryAccount.get_default_fields(), xfer)
link_grid_lines.set_location(0, 2, 2)
link_grid_lines.add_action(xfer.request, ActionsManage.get_action_url('accounting.EntryAccount', 'OpenFromLine', xfer),
modal=FORMTYPE_MODAL, unique=SELECT_SINGLE, close=CLOSE_NO)
link_grid_lines.add_action(xfer.request, ActionsManage.get_action_url('accounting.EntryAccount', 'Close', xfer),
modal=FORMTYPE_MODAL, unique=SELECT_MULTI, close=CLOSE_NO)
link_grid_lines.add_action(xfer.request, ActionsManage.get_action_url('accounting.EntryAccount', 'Link', xfer),
modal=FORMTYPE_MODAL, unique=SELECT_MULTI, close=CLOSE_NO)
xfer.add_component(link_grid_lines)
except LucteriosException:
pass
def edit(self, xfer):
set_comp = xfer.get_components('set')
set_comp.set_select_query(Set.objects.filter(is_active=True))
xfer.get_components('price').prec = Params.getvalue(
"accounting-devise-prec")
old_account = xfer.get_components("expense_account")
xfer.remove_component("expense_account")
sel_account = XferCompSelect("expense_account")
sel_account.description = old_account.description
sel_account.set_location(old_account.col, old_account.row,
old_account.colspan, old_account.rowspan)
for item in FiscalYear.get_current().chartsaccount_set.all().filter(
code__regex=current_system_account().get_expence_mask(
)).order_by('code'):
sel_account.select_list.append((item.code, six.text_type(item)))
sel_account.set_value(self.item.expense_account)
xfer.add_component(sel_account)
self.item.year = FiscalYear.get_current()
btn = XferCompButton('add_account')
btn.set_location(old_account.col + 1, old_account.row)
btn.set_is_mini(True)
btn.set_action(xfer.request,
ActionsManage.get_action_url('accounting.ChartsAccount',
'AddModify', xfer),
close=CLOSE_NO,
modal=FORMTYPE_MODAL,
params={'year': self.item.year.id})
xfer.add_component(btn)
xfer.get_components("set").colspan = old_account.colspan + 1
xfer.get_components("designation").colspan = old_account.colspan + 1
xfer.get_components("price").colspan = old_account.colspan + 1
def default_setowner_fr(with_lots=True):
if Params.getvalue("condominium-old-accounting"):
create_account(['450'], 0, FiscalYear.get_current())
else:
create_account(['4501', '4502', '4503', '4504', '4505'], 0,
FiscalYear.get_current())
create_account(['120', '103', '105'], 2, FiscalYear.get_current())
create_account(['702'], 3, FiscalYear.get_current())
set1 = Set.objects.create(name="AAA",
budget=1000,
revenue_account='701',
is_link_to_lots=with_lots,
type_load=0)
_set_budget(set1, '604', 1000)
set2 = Set.objects.create(name="BBB",
budget=100,
revenue_account='701',
type_load=0)
_set_budget(set2, '604', 100)
set3 = Set.objects.create(name="CCC",
budget=500,
revenue_account='702',
type_load=1)
_set_budget(set3, '604', 500)
set4 = Set.objects.create(name="OLD",
budget=100,
revenue_account='702',
type_load=1,
is_active=False)
_set_budget(set4, '602', 100)
_create_owners(set1, set2, set3, set4, with_lots)
Owner.check_all_account()
def editbudget_condo(xfer):
if xfer.getparam('set') is not None:
cost = xfer.getparam('cost_accounting')
if cost is not None:
set_item = Set.objects.get(id=xfer.getparam('set', 0))
title_cost = xfer.get_components('title_cost')
xfer.remove_component('title_year')
year = xfer.getparam('year', 0)
select_year = XferCompSelect('year')
select_year.set_location(1, title_cost.row - 1)
select_year.set_select_query(FiscalYear.objects.all())
select_year.set_value(year)
select_year.description = _('year')
select_year.set_needed(set_item.type_load == Set.TYPELOAD_CURRENT)
select_year.set_action(xfer.request,
xfer.__class__.get_action(),
close=CLOSE_NO,
modal=FORMTYPE_REFRESH)
xfer.add_component(select_year)
btn = XferCompButton('confyear')
btn.set_location(2, title_cost.row - 1)
btn.set_action(xfer.request,
ActionsManage.get_action_url(
FiscalYear.get_long_name(), 'configuration',
xfer),
close=CLOSE_NO)
btn.set_is_mini(True)
xfer.add_component(btn)
if year != 0:
current_year = FiscalYear.get_current(year)
xfer.params['readonly'] = str(
current_year.status == FiscalYear.STATUS_FINISHED)
if set_item.type_load == 0:
if len(set_item.setcost_set.filter(
year=current_year)) == 0:
set_item.create_new_cost(year=current_year.id)
setcost_item = set_item.setcost_set.filter(
year=current_year)[0]
else:
setcost_item = set_item.setcost_set.filter(year=None)[0]
cost_item = setcost_item.cost_accounting
xfer.params['cost_accounting'] = cost_item.id
title_cost.set_value("{[b]}%s{[/b]} : %s" %
(_('cost accounting'), cost_item))
else:
year = None
xfer.params['readonly'] = 'True'
cost_item = CostAccounting.objects.get(id=cost)
if (cost_item.status
== CostAccounting.STATUS_OPENED) and not xfer.getparam(
'readonly', False):
set_item.change_budget_product(cost_item, year)
if xfer.getparam('type_of_account') is not None:
xfer.params['readonly'] = 'True'
return
def default_setowner(with_lots=True):
def set_partition(setpart, owner, value):
part = Partition.objects.get(set=setpart, owner=owner)
part.value = value
part.save()
if Params.getvalue("condominium-old-accounting"):
create_account(['450'], 0, FiscalYear.get_current())
else:
create_account(['4501', '4502', '4503', '4504'], 0, FiscalYear.get_current())
create_account(['120', '103'], 2, FiscalYear.get_current())
create_account(['702'], 3, FiscalYear.get_current())
owner1 = Owner.objects.create(third_id=4)
owner1.editor.before_save(None)
owner1.save()
owner2 = Owner.objects.create(third_id=5)
owner2.editor.before_save(None)
owner2.save()
owner3 = Owner.objects.create(third_id=7)
owner3.editor.before_save(None)
owner3.save()
if with_lots:
PropertyLot.objects.create(num=1, value=45.0, description="Appart A", owner=owner1)
PropertyLot.objects.create(num=2, value=35.0, description="Appart B", owner=owner2)
PropertyLot.objects.create(num=3, value=20.0, description="Appart C", owner=owner3)
set1 = Set.objects.create(
name="AAA", budget=1000, revenue_account='701', is_link_to_lots=with_lots, type_load=0, cost_accounting_id=2)
set1.convert_budget()
set2 = Set.objects.create(
name="BBB", budget=100, revenue_account='701', type_load=0, cost_accounting_id=0)
set2.convert_budget()
set3 = Set.objects.create(
name="CCC", budget=500, revenue_account='702', type_load=1, cost_accounting_id=0)
set3.convert_budget()
set4 = Set.objects.create(
name="OLD", budget=100, revenue_account='702', type_load=1, cost_accounting_id=0, is_active=False)
set4.convert_budget()
if with_lots:
set1.set_of_lots = PropertyLot.objects.all()
set1.save()
else:
set_partition(setpart=set1, owner=owner1, value=45.0)
set_partition(setpart=set1, owner=owner2, value=35.0)
set_partition(setpart=set1, owner=owner3, value=20.0)
set_partition(setpart=set2, owner=owner1, value=75.0)
set_partition(setpart=set2, owner=owner2, value=0.0)
set_partition(setpart=set2, owner=owner3, value=25.0)
set_partition(setpart=set3, owner=owner1, value=45.0)
set_partition(setpart=set3, owner=owner2, value=35.0)
set_partition(setpart=set3, owner=owner3, value=20.0)
set_partition(setpart=set4, owner=owner1, value=45.0)
set_partition(setpart=set4, owner=owner2, value=35.0)
set_partition(setpart=set4, owner=owner3, value=20.0)
def thirdaddon_invoice(item, xfer):
if WrapAction.is_permission(xfer.request, 'invoice.change_bill'):
try:
FiscalYear.get_current()
xfer.new_tab(_('Invoice'))
current_filter, status_filter = _add_bill_filter(xfer, 1)
current_filter &= Q(third=item)
bills = Bill.objects.filter(current_filter)
bill_grid = XferCompGrid('bill')
bill_grid.set_model(bills, Bill.get_default_fields(status_filter), xfer)
bill_grid.set_location(0, 2, 2)
bill_grid.add_action(xfer.request, ActionsManage.get_action_url('invoice.Bill', 'Show', xfer), modal=FORMTYPE_MODAL, unique=SELECT_SINGLE, close=CLOSE_NO)
xfer.add_component(bill_grid)
except LucteriosException:
pass
def fillresponse(self):
current_year = FiscalYear.get_current()
if self.item.type_load == 0:
for year_item in FiscalYear.objects.filter(
begin__gte=current_year.begin):
costs = self.item.setcost_set.filter(year=year_item)
if len(costs) == 0:
self.item.create_new_cost(year=year_item.id)
img = XferCompImage('img')
img.set_value(self.icon_path())
img.set_location(0, 0)
self.add_component(img)
lbl = XferCompLabelForm('title')
lbl.set_value_as_title(self.item.name)
lbl.set_location(1, 0)
self.add_component(lbl)
self.fill_grid(
0, CostAccounting, 'costaccounting',
CostAccounting.objects.filter(
setcost__set=self.item).order_by('-setcost__year__begin'))
grid = self.get_components('costaccounting')
grid.delete_header("is_default")
new_actions = []
grid = self.get_components('costaccounting')
for grid_action in grid.actions:
if grid_action[0].icon_path.endswith('images/print.png'):
new_actions.append(grid_action)
grid.actions = new_actions
grid.add_action(self.request,
ClassCategoryBudget.get_action(),
close=CLOSE_NO,
unique=SELECT_SINGLE)
self.add_action(WrapAction(TITLE_CLOSE, 'images/close.png'))
def check_date(self, date):
info = []
fiscal_year = FiscalYear.get_current()
if (fiscal_year.begin.isoformat() > date) or (fiscal_year.end.isoformat() < date):
info.append(
six.text_type(_("date not include in current fiscal year")))
return info
def fillresponse_header(self):
status_filter = self.getparam('status_filter', 0)
self.params['status_filter'] = status_filter
date_filter = self.getparam('date_filter', 0)
self.fieldnames = Expense.get_default_fields(status_filter)
lbl = XferCompLabelForm('lbl_status_filter')
lbl.set_value_as_name(_('Filter by type'))
lbl.set_location(0, 3)
self.add_component(lbl)
dep_field = self.item.get_field_by_name('status')
sel_list = list(dep_field.choices)
edt = XferCompSelect("status_filter")
edt.set_select(sel_list)
edt.set_value(status_filter)
edt.set_location(1, 3)
edt.set_action(self.request, self.get_action(), modal=FORMTYPE_REFRESH, close=CLOSE_NO)
self.add_component(edt)
lbl = XferCompLabelForm('lbl_date_filter')
lbl.set_value_as_name(_('Filter by date'))
lbl.set_location(0, 4)
self.add_component(lbl)
edt = XferCompSelect("date_filter")
edt.set_select([(0, _('only current fiscal year')), (1, _('all expenses'))])
edt.set_value(date_filter)
edt.set_location(1, 4)
edt.set_action(self.request, self.get_action(), modal=FORMTYPE_REFRESH, close=CLOSE_NO)
self.add_component(edt)
self.filter = Q(status=status_filter)
if date_filter == 0:
current_year = FiscalYear.get_current()
self.filter &= Q(date__gte=current_year.begin) & Q(date__lte=current_year.end)
def finalizeyear_condo(xfer):
year = FiscalYear.get_current(xfer.getparam('year'))
if year is not None:
ventilate = xfer.getparam("ventilate", 0)
if xfer.observer_name == "core.custom":
if year.check_to_close() > 0:
raise LucteriosException(IMPORTANT, _("This fiscal year has entries not closed!"))
result = year.total_revenue - year.total_expense
if abs(result) > 0.001:
row = xfer.get_max_row() + 1
lbl = XferCompLabelForm('title_condo')
lbl.set_value(_('This fiscal year has a result no null equals to %s.') % format_devise(result, 5))
lbl.set_location(0, row, 2)
xfer.add_component(lbl)
lbl = XferCompLabelForm('question_condo')
lbl.set_value(_('Where do you want to ventilate this amount?'))
lbl.set_location(0, row + 1)
xfer.add_component(lbl)
sel_cmpt = [('0', _("For each owner"))]
for account in year.chartsaccount_set.filter(type_of_account=2).order_by('code'):
sel_cmpt.append((account.id, six.text_type(account)))
sel = XferCompSelect("ventilate")
sel.set_select(sel_cmpt)
sel.set_value(ventilate)
sel.set_location(1, row + 1)
xfer.add_component(sel)
elif xfer.observer_name == "core.acknowledge":
for set_cost in year.setcost_set.filter(year=year, set__is_active=True, set__type_load=0):
if ventilate == 0:
current_system_condo().ventilate_costaccounting(set_cost.set, set_cost.cost_accounting, 1, Params.getvalue("condominium-current-revenue-account"))
set_cost.cost_accounting.close()
current_system_condo().ventilate_result(year, ventilate)
def fillresponse_header(self):
status_filter = self.getparam('status_filter', 0)
self.params['status_filter'] = status_filter
date_filter = self.getparam('date_filter', 0)
self.fieldnames = Expense.get_default_fields(status_filter)
dep_field = self.item.get_field_by_name('status')
sel_list = list(dep_field.choices)
edt = XferCompSelect("status_filter")
edt.set_select(sel_list)
edt.set_value(status_filter)
edt.description = _('Filter by type')
edt.set_location(0, 3)
edt.set_action(self.request,
self.get_action(),
modal=FORMTYPE_REFRESH,
close=CLOSE_NO)
self.add_component(edt)
edt = XferCompSelect("date_filter")
edt.set_select([(0, _('only current fiscal year')),
(1, _('all expenses'))])
edt.set_value(date_filter)
edt.set_location(0, 4)
edt.description = _('Filter by date')
edt.set_action(self.request,
self.get_action(),
modal=FORMTYPE_REFRESH,
close=CLOSE_NO)
self.add_component(edt)
self.filter = Q(status=status_filter)
if date_filter == 0:
current_year = FiscalYear.get_current()
self.filter &= Q(date__gte=current_year.begin) & Q(
date__lte=current_year.end)
def finalizeyear_condo(xfer):
year = FiscalYear.get_current(xfer.getparam('year'))
if year is not None:
ventilate = xfer.getparam("ventilate", 0)
if xfer.observer_name == "core.custom":
if year.check_to_close() > 0:
raise LucteriosException(IMPORTANT, _("This fiscal year has entries not closed!"))
result = year.total_revenue - year.total_expense
if abs(result) > 0.001:
row = xfer.get_max_row() + 1
lbl = XferCompLabelForm('title_condo')
lbl.set_value(_('This fiscal year has a result no null equals to %s.') % format_devise(result, 5))
lbl.set_location(0, row, 2)
xfer.add_component(lbl)
lbl = XferCompLabelForm('question_condo')
lbl.set_value(_('Where do you want to ventilate this amount?'))
lbl.set_location(0, row + 1)
xfer.add_component(lbl)
sel_cmpt = [('0', _("For each owner"))]
for account in year.chartsaccount_set.filter(type_of_account=2).order_by('code'):
sel_cmpt.append((account.id, six.text_type(account)))
sel = XferCompSelect("ventilate")
sel.set_select(sel_cmpt)
sel.set_value(ventilate)
sel.set_location(1, row + 1)
xfer.add_component(sel)
elif xfer.observer_name == "core.acknowledge":
for set_cost in year.setcost_set.filter(year=year, set__is_active=True, set__type_load=0):
if ventilate == 0:
set_cost.set.ventilate_costaccounting(set_cost.cost_accounting, 1,
Params.getvalue("condominium-current-revenue-account"))
set_cost.cost_accounting.close()
ventilate_result(year, ventilate)
def fill_header(self):
self.item = FiscalYear.get_current(self.getparam("year"))
new_begin = convert_date(self.getparam("begin"), self.item.begin)
new_end = convert_date(self.getparam("end"), self.item.end)
if (new_begin >= self.item.begin) and (new_end <= self.item.end):
self.item.begin = new_begin
self.item.end = new_end
img = XferCompImage('img')
img.set_value(self.current_image())
if not img.value.startswith('/static/'):
img.type = 'jpg'
img.set_location(0, 0, 1, 5)
self.add_component(img)
if self.item.last_fiscalyear is not None:
lbl = XferCompLabelForm('year_1')
lbl.set_location(1, 0, 3)
lbl.description = _('year N-1')
lbl.set_value(six.text_type(self.item.last_fiscalyear))
self.add_component(lbl)
select_year = XferCompSelect(self.field_id)
select_year.set_location(1, 1, 3)
select_year.set_select_query(FiscalYear.objects.all())
select_year.description = _('year N')
select_year.set_value(self.item.id)
select_year.set_needed(True)
select_year.set_action(self.request,
self.__class__.get_action(),
close=CLOSE_NO,
modal=FORMTYPE_REFRESH)
self.add_component(select_year)
self.filter = Q(entry__year=self.item)
self.lastfilter = Q(entry__year=self.item.last_fiscalyear)
def default_setowner_be(with_lots=True):
create_account(['410000', '410100'], 0, FiscalYear.get_current())
create_account(['100000', '160000'], 2, FiscalYear.get_current())
create_account(['700100', '701100', '701200'], 3, FiscalYear.get_current())
set1 = Set.objects.create(name="AAA",
is_link_to_lots=with_lots,
type_load=0)
_set_budget(set1, '602000', 1200)
set2 = Set.objects.create(name="BBB", type_load=0)
_set_budget(set2, '602000', 120)
set3 = Set.objects.create(name="CCC", type_load=1)
_set_budget(set3, '602000', 600)
set4 = Set.objects.create(name="OLD", type_load=1, is_active=False)
_set_budget(set4, '601000', 120)
_create_owners(set1, set2, set3, set4, with_lots)
Owner.check_all_account()
def get_info_state(self):
info = []
if self.status == 0:
info = Supporting.get_info_state(
self, current_system_account().get_customer_mask())
details = self.detail_set.all()
if len(details) == 0:
info.append(six.text_type(_("no detail")))
else:
for detail in details:
if detail.article is not None:
detail_code = detail.article.sell_account
else:
detail_code = Params.getvalue(
"invoice-default-sell-account")
detail_account = None
if match(current_system_account().get_revenue_mask(), detail_code) is not None:
try:
detail_account = ChartsAccount.get_account(
detail_code, FiscalYear.get_current())
except LucteriosException:
break
if detail_account is None:
info.append(
six.text_type(_("article has code account unknown!")))
break
try:
info.extend(self.check_date(self.date.isoformat()))
except LucteriosException:
pass
return "{[br/]}".join(info)
def summary_accounting(xfer):
if WrapAction.is_permission(xfer.request, 'accounting.change_chartsaccount'):
row = xfer.get_max_row() + 1
lab = XferCompLabelForm('accountingtitle')
lab.set_value_as_infocenter(_("Bookkeeping"))
lab.set_location(0, row, 4)
xfer.add_component(lab)
try:
year = FiscalYear.get_current()
lbl = XferCompLabelForm("accounting_year")
lbl.set_value_center(six.text_type(year))
lbl.set_location(0, row + 1, 4)
xfer.add_component(lbl)
lbl = XferCompLabelForm("accounting_result")
lbl.set_value_center(year.total_result_text)
lbl.set_location(0, row + 2, 4)
xfer.add_component(lbl)
except LucteriosException as lerr:
lbl = XferCompLabelForm("accounting_error")
lbl.set_value_center(six.text_type(lerr))
lbl.set_location(0, row + 1, 4)
xfer.add_component(lbl)
btn = XferCompButton("accounting_conf")
btn.set_action(xfer.request, Configuration.get_action(_("conf."), ""), close=CLOSE_NO)
btn.set_location(0, row + 2, 4)
xfer.add_component(btn)
lab = XferCompLabelForm('accountingend')
lab.set_value_center('{[hr/]}')
lab.set_location(0, row + 3, 4)
xfer.add_component(lab)
return True
else:
return False
def edit_account_for_line(self, xfer, column, row, debit_rest, credit_rest):
num_cpt_txt = xfer.getparam('num_cpt_txt', '')
num_cpt = xfer.getparam('num_cpt', 0)
lbl = XferCompLabelForm('numCptlbl')
lbl.set_location(column, row, 3)
lbl.set_value_as_headername(_('account'))
xfer.add_component(lbl)
edt = XferCompEdit('num_cpt_txt')
edt.set_location(column, row + 1, 2)
edt.set_value(num_cpt_txt)
edt.set_size(20, 25)
edt.set_action(xfer.request, xfer.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
xfer.add_component(edt)
sel_val = []
current_account = None
if num_cpt_txt != '':
year = FiscalYear.get_current(xfer.getparam('year'))
sel_val, current_account = year.get_account_list(num_cpt_txt, num_cpt)
sel = XferCompSelect('num_cpt')
sel.set_location(column + 2, row + 1, 1)
sel.set_select(sel_val)
sel.set_size(20, 150)
sel.set_action(xfer.request, xfer.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
if current_account is not None:
sel.set_value(current_account.id)
self.item.account = current_account
self.item.set_montant(
float(xfer.getparam('debit_val', 0.0)), float(xfer.getparam('credit_val', 0.0)))
if abs(self.item.amount) < 0.0001:
self.item.set_montant(debit_rest, credit_rest)
xfer.add_component(sel)
return lbl, edt
def conf_wizard_accounting(wizard_ident, xfer):
if isinstance(wizard_ident, list) and (xfer is None):
wizard_ident.append(("accounting_params", 21))
wizard_ident.append(("accounting_fiscalyear", 22))
wizard_ident.append(("accounting_journal", 23))
elif (xfer is not None) and (wizard_ident == "accounting_params"):
xfer.add_title(_("Diacamma accounting"), _('Parameters'), _('Configuration of accounting parameters'))
select_account_system(xfer)
fill_params(xfer, True)
elif (xfer is not None) and (wizard_ident == "accounting_fiscalyear"):
xfer.add_title(_("Diacamma accounting"), _('Fiscal year list'), _('Configuration of fiscal years'))
xfer.fill_grid(5, FiscalYear, 'fiscalyear', FiscalYear.objects.all())
try:
current_year = FiscalYear.get_current()
nb_account = len(ChartsAccount.objects.filter(year=current_year))
lbl = XferCompLabelForm('nb_account')
lbl.set_value(_("Total of charts of accounts in current fiscal year: %d") % nb_account)
lbl.set_location(0, 10)
xfer.add_component(lbl)
if nb_account == 0:
xfer.item = ChartsAccount()
xfer.item.year = current_year
btn = XferCompButton('initialfiscalyear')
btn.set_location(1, 10)
btn.set_action(xfer.request, ActionsManage.get_action_url(ChartsAccount.get_long_name(), 'AccountInitial', xfer), close=CLOSE_NO)
xfer.add_component(btn)
except LucteriosException as lerr:
lbl = XferCompLabelForm('nb_account')
lbl.set_value(six.text_type(lerr))
lbl.set_location(0, 10, 2)
xfer.add_component(lbl)
elif (xfer is not None) and (wizard_ident == "accounting_journal"):
xfer.add_title(_("Diacamma accounting"), _('Journals'), _('Configuration of journals'))
xfer.fill_grid(5, Journal, 'journal', Journal.objects.all())
def _filter_by_year(self):
select_year = self.getparam('year')
self.item.year = FiscalYear.get_current(select_year)
self.item.journal = Journal.objects.get(id=1)
self.fill_from_model(0, 1, False, ['year', 'journal'])
self.get_components('year').set_action(self.request, self.get_action(), modal=FORMTYPE_REFRESH, close=CLOSE_NO)
self.filter = Q(year=self.item.year)
def init_compta():
year = FiscalYear.get_current()
if Params.getvalue("condominium-old-accounting"):
add_entry(year.id, 1, '2015-01-01', 'Report à nouveau',
'-1|2|0|23.450000|0|0|None|\n-2|17|4|-23.450000|0|0|None|',
True)
elif get_accounting_system() == 'FR':
add_entry(
year.id, 1, '2015-01-01', 'Report à nouveau',
"""-1|2|0|16.680000|0|0|None|
-2|17|4|-23.450000|0|0|None|
-3|18|4|-5.730000|0|0|None|
-4|17|5|10.500000|0|0|None|
-5|18|5|0.7500000|0|0|None|
-6|19|5|0.6000000|0|0|None|
-7|20|5|0.250000|0|0|None|
-8|21|5|0.400000|0|0|None|""", True)
elif get_accounting_system() == 'BE':
add_entry(
year.id, 1, '2015-01-01', 'Report à nouveau',
"""-1|2|0|16.680000|0|0|None|
-2|17|4|-23.450000|0|0|None|
-3|18|4|-5.730000|0|0|None|
-4|17|5|12.500000|0|0|None|""", True)
add_entry(year.id, 5, '2015-02-20', 'Frais bancaire',
'-1|2|0|-12.340000|0|0|None|\n-2|15|0|12.340000|0|0|None|', True)
def fillresponse(self):
year_item = FiscalYear.get_current()
if self.item.type_load == 0:
if len(self.item.setcost_set.filter(year=year_item)) == 0:
self.item.create_new_cost(year=year_item.id)
cost_item = self.item.setcost_set.filter(year=year_item)[0]
params = {'costaccounting': cost_item.cost_accounting.id}
self.redirect_action(CostAccountingIncomeStatement.get_action(), close=CLOSE_YES, params=params)
def _set_budget(setitem, code, amount):
year = FiscalYear.get_current()
cost = setitem.current_cost_accounting
Budget.objects.create(cost_accounting=cost,
year=year,
code=code,
amount=amount)
setitem.change_budget_product(cost, year.id)
def CurrentCallFundsAdding(self, to_create):
if to_create:
nb_seq = 0
if Params.getvalue("condominium-mode-current-callfunds") == 0:
nb_seq = 4
if Params.getvalue("condominium-mode-current-callfunds") == 1:
nb_seq = 12
year = FiscalYear.get_current()
for num in range(nb_seq):
date = same_day_months_after(year.begin, int(num * 12 / nb_seq))
new_call = CallFunds.objects.create(date=date, comment=_("Call of funds #%(num)d of year from %(begin)s to %(end)s") % {'num': num + 1, 'begin': get_value_converted(year.begin), 'end': get_value_converted(year.end)}, status=0)
for category in Set.objects.filter(type_load=0, is_active=True):
CallDetail.objects.create(set=category, type_call=0, callfunds=new_call, price=category.get_current_budget() / nb_seq, designation=_("%(type)s - #%(num)d") % {'type': _('current'), 'num': num + 1})
else:
year = FiscalYear.get_current()
calls = CallFunds.objects.filter(date__gte=year.begin, date__lte=year.end, calldetail__type_call=0).distinct()
return len(calls) == 0
def default_articles():
default_costaccounting()
create_account(['709'], 3, FiscalYear.get_current())
create_account(['4455'], 1, FiscalYear.get_current())
vat1 = Vat.objects.create(name="5%", rate=5.0, isactif=True)
vat2 = Vat.objects.create(name="20%", rate=20.0, isactif=True)
Article.objects.create(reference='ABC1', designation="Article 01",
price="12.34", unit="kg", isdisabled=False, sell_account="701", vat=None)
Article.objects.create(reference='ABC2', designation="Article 02",
price="56.78", unit="l", isdisabled=False, sell_account="707", vat=vat1)
Article.objects.create(reference='ABC3', designation="Article 03",
price="324.97", unit="", isdisabled=False, sell_account="601", vat=None)
Article.objects.create(reference='ABC4', designation="Article 04",
price="1.31", unit="", isdisabled=False, sell_account="708", vat=None)
Article.objects.create(reference='ABC5', designation="Article 05",
price="64.10", unit="m", isdisabled=True, sell_account="701", vat=vat2)
def get_filter(self):
if self.getparam('CRITERIA') is None:
select_year = self.getparam('year')
select_type = self.getparam('type_of_account', 0)
new_filter = Q(year=FiscalYear.get_current(select_year))
if select_type != -1:
new_filter &= Q(type_of_account=select_type)
else:
new_filter = XferPrintListing.get_filter(self)
return new_filter
def init_compta():
year = FiscalYear.get_current()
if Params.getvalue("condominium-old-accounting"):
add_entry(year.id, 1, '2015-01-01', 'Report à nouveau',
'-1|2|0|23.450000|None|\n-2|17|4|-23.450000|None|', True)
else:
add_entry(year.id, 1, '2015-01-01', 'Report à nouveau',
'-1|2|0|29.180000|None|\n-2|17|4|-23.450000|None|\n-3|18|4|-5.730000|None|', True)
add_entry(year.id, 5, '2015-02-20', 'Frais bancaire',
'-1|2|0|-12.340000|None|\n-2|15|0|12.340000|None|', True)
def init_compta():
year = FiscalYear.get_current()
if Params.getvalue("condominium-old-accounting"):
add_entry(year.id, 1, '2015-01-01', 'Report à nouveau',
'-1|2|0|23.450000|0|None|\n-2|17|4|-23.450000|0|None|', True)
else:
add_entry(
year.id, 1, '2015-01-01', 'Report à nouveau',
'-1|2|0|16.680000|0|None|\n-2|17|4|-23.450000|0|None|\n-3|18|4|-5.730000|0|None|\n-4|17|5|12.500000|0|None|',
True)
add_entry(year.id, 5, '2015-02-20', 'Frais bancaire',
'-1|2|0|-12.340000|0|None|\n-2|15|0|12.340000|0|None|', True)
def valid(self):
self.fiscal_year = FiscalYear.get_current()
bill_list = Bill.objects.filter(Q(bill_type=self.bill_type) & Q(fiscal_year=self.fiscal_year)).exclude(status=0)
val = bill_list.aggregate(Max('num'))
if val['num__max'] is None:
self.num = 1
else:
self.num = val['num__max'] + 1
self.status = 1
if self.bill_type != 0:
self.generate_entry()
self.save()
Signal.call_signal("change_bill", 'valid', self, None)
def fillresponse_header(self):
select_year = self.getparam('year')
select_type = self.getparam('type_of_account', 0)
self.item.year = FiscalYear.get_current(select_year)
self.fill_from_model(0, 1, False, ['year', 'type_of_account'])
self.get_components('year').set_action(self.request, self.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
type_of_account = self.get_components('type_of_account')
type_of_account.select_list.append((-1, '---'))
type_of_account.set_value(select_type)
type_of_account.set_action(self.request, ChartsAccountList.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
self.filter = Q(year=self.item.year)
if select_type != -1:
self.filter &= Q(type_of_account=select_type)
def fill_header(self):
img = XferCompImage('img')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 2)
self.add_component(img)
select_year = self.getparam('fiscal_year')
lbl = XferCompLabelForm('lbl_title')
lbl.set_value_as_headername(_('Statistics in date of %s') % formats.date_format(date.today(), "DATE_FORMAT"))
lbl.set_location(1, 0, 2)
self.add_component(lbl)
self.item.fiscal_year = FiscalYear.get_current(select_year)
self.fill_from_model(1, 1, False, ['fiscal_year'])
fiscal_year = self.get_components('fiscal_year')
fiscal_year.set_needed(True)
fiscal_year.set_action(self.request, self.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
def edit(self, xfer):
old_account = xfer.get_components("code")
xfer.remove_component("code")
sel_code = XferCompSelect("code")
sel_code.set_location(old_account.col, old_account.row,
old_account.colspan + 1, old_account.rowspan)
existed_codes = []
for acc_ratio in RecoverableLoadRatio.objects.all():
existed_codes.append(acc_ratio.code)
for item in FiscalYear.get_current().chartsaccount_set.all().filter(
code__regex=current_system_account().get_expence_mask(
)).exclude(code__in=existed_codes).order_by('code'):
sel_code.select_list.append((item.code, str(item)))
sel_code.set_value(self.item.code)
xfer.add_component(sel_code)
def add_years():
year_N_1 = FiscalYear.objects.create(begin='2014-01-01',
end='2014-12-31',
status=2)
year = FiscalYear.get_current()
year.last_fiscalyear = year_N_1
year.save()
year_N1 = FiscalYear.objects.create(begin='2016-01-01',
end='2016-12-31',
status=0,
last_fiscalyear=year)
FiscalYear.objects.create(begin='2017-01-01',
end='2017-12-31',
status=0,
last_fiscalyear=year_N1)
def edit(self, xfer):
set_comp = xfer.get_components('set')
set_comp.set_select_query(Set.objects.filter(is_active=True))
xfer.get_components('price').prec = Params.getvalue(
"accounting-devise-prec")
old_account = xfer.get_components("expense_account")
xfer.remove_component("expense_account")
sel_account = XferCompSelect("expense_account")
sel_account.set_location(old_account.col, old_account.row, old_account.colspan, old_account.rowspan)
for item in FiscalYear.get_current().chartsaccount_set.all().filter(code__regex=current_system_account().get_expence_mask()).order_by('code'):
sel_account.select_list.append((item.code, six.text_type(item)))
sel_account.set_value(self.item.expense_account)
xfer.add_component(sel_account)
self.item.year = FiscalYear.get_current()
btn = XferCompButton('add_account')
btn.set_location(old_account.col + 1, old_account.row)
btn.set_is_mini(True)
btn.set_action(xfer.request, ActionsManage.get_action_url('accounting.ChartsAccount', 'AddModify', xfer),
close=CLOSE_NO, modal=FORMTYPE_MODAL, params={'year': self.item.year.id})
xfer.add_component(btn)
xfer.get_components("set").colspan = old_account.colspan + 1
xfer.get_components("designation").colspan = old_account.colspan + 1
xfer.get_components("price").colspan = old_account.colspan + 1
def ventilate_costaccounting(self, own_set, cost_accounting, type_owner,
initial_code):
if type_owner == 2:
result = currency_round(
CallDetail.objects.filter(set=own_set).aggregate(
sum=Sum('price'))['sum'])
else:
result = cost_accounting.get_total_revenue()
result -= cost_accounting.get_total_expense()
if abs(result) > 0.0001:
fiscal_year = FiscalYear.get_current()
close_entry = EntryAccount(year=fiscal_year,
designation=_("Ventilation for %s") %
own_set,
journal_id=5)
close_entry.check_date()
close_entry.save()
amount = 0
last_line = None
for part in own_set.partition_set.all().order_by('value'):
value = currency_round(result * part.get_ratio() / 100.0)
if abs(value) > 0.0001:
owner_account = part.owner.third.get_account(
fiscal_year, part.owner.get_third_mask(type_owner))
last_line = EntryLineAccount.objects.create(
account=owner_account,
amount=-1 * value,
entry=close_entry,
third=part.owner.third)
amount += value
if last_line is None:
raise LucteriosException(
IMPORTANT,
_('The class load %s has no owner') % own_set)
diff = currency_round(result - amount)
if abs(diff) > 0.0001:
last_line.amount -= diff
last_line.save()
reserve_account = ChartsAccount.get_account(
initial_code, fiscal_year)
EntryLineAccount.objects.create(account=reserve_account,
amount=-1 * result,
entry=close_entry,
costaccounting=cost_accounting)
close_entry.closed()
def thirdaddon_expense(item, xfer):
if WrapAction.is_permission(xfer.request, 'condominium.change_expense'):
try:
status_filter = xfer.getparam('status_filter',
Expense.STATUS_BUILDING)
date_filter = xfer.getparam('date_filter', 0)
current_year = FiscalYear.get_current()
item.get_account(current_year,
current_system_account().get_provider_mask())
xfer.new_tab(_('Expenses'))
edt = XferCompSelect("status_filter")
edt.set_select(list(Expense.get_field_by_name('status').choices))
edt.set_value(status_filter)
edt.description = _('Filter by type')
edt.set_location(0, 1)
edt.set_action(xfer.request,
xfer.return_action(),
modal=FORMTYPE_REFRESH,
close=CLOSE_NO)
xfer.add_component(edt)
edt = XferCompSelect("date_filter")
edt.set_select([(0, _('only current fiscal year')),
(1, _('all expenses'))])
edt.set_value(date_filter)
edt.set_location(0, 2)
edt.description = _('Filter by date')
edt.set_action(xfer.request,
xfer.return_action(),
modal=FORMTYPE_REFRESH,
close=CLOSE_NO)
xfer.add_component(edt)
expense_filter = Q(status=status_filter) & Q(third=item)
if date_filter == 0:
expense_filter &= Q(date__gte=current_year.begin) & Q(
date__lte=current_year.end)
expenses = Expense.objects.filter(expense_filter).distinct()
expense_grid = XferCompGrid('expense')
expense_grid.set_model(expenses,
Expense.get_default_fields(status_filter),
xfer)
expense_grid.add_action_notified(xfer, Expense)
expense_grid.set_location(0, 3, 2)
xfer.add_component(expense_grid)
except LucteriosException:
pass
def fillresponse(self, journal=0):
if self.getparam('SAVE') is None:
dlg = self.create_custom()
image = XferCompImage('image')
image.set_value(self.icon_path())
image.set_location(0, 0, 1, 6)
dlg.add_component(image)
lbl = XferCompLabelForm('lblmodel')
lbl.set_value(_('model name'))
lbl.set_location(1, 0)
dlg.add_component(lbl)
if journal > 0:
mod_query = ModelEntry.objects.filter(journal=journal)
else:
mod_query = ModelEntry.objects.all()
sel = XferCompSelect('model')
sel.set_location(2, 0)
sel.set_needed(True)
sel.set_select_query(mod_query)
dlg.add_component(sel)
lbl = XferCompLabelForm('lblfactor')
lbl.set_value(_('factor'))
lbl.set_location(1, 1)
dlg.add_component(lbl)
fact = XferCompFloat('factor', 0.00, 1000000.0, 2)
fact.set_value(1.0)
fact.set_location(2, 1)
dlg.add_component(fact)
dlg.add_action(self.get_action(TITLE_OK, 'images/ok.png'), params={"SAVE": "YES"})
dlg.add_action(WrapAction(TITLE_CANCEL, 'images/cancel.png'))
else:
factor = self.getparam('factor', 1.0)
model = ModelEntry.objects.get(id=self.getparam('model', 0))
for old_key in ['SAVE', 'model', 'factor']:
if old_key in self.params.keys():
del self.params[old_key]
year = FiscalYear.get_current(self.getparam('year'))
serial_entry = model.get_serial_entry(factor, year)
date_value = date.today().isoformat()
entry = EntryAccount.objects.create(year=year, date_value=date_value, designation=model.designation,
journal=model.journal, costaccounting=model.costaccounting)
entry.editor.before_save(self)
self.params["entryaccount"] = entry.id
self.redirect_action(EntryAccountEdit.get_action(), params={"serial_entry": serial_entry})
def fillresponse(self):
if self.getparam("year") is None:
self.item = FiscalYear.get_current()
destination_file = self.item.get_xml_export()
img = XferCompImage('img')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 6)
self.add_component(img)
lbl = XferCompLabelForm('title')
lbl.set_value_as_title(_('Export fiscal year'))
lbl.set_location(1, 0)
self.add_component(lbl)
down = XferCompDownLoad('filename')
down.compress = False
down.set_value('export_year_%s_%s.xml' %
(self.item.begin.isoformat(), self.item.end.isoformat()))
down.set_download(destination_file)
down.set_location(1, 1)
self.add_component(down)
def fillresponse_header(self):
self.filter = Q()
if self.getparam('year') is not None:
year = FiscalYear.get_current(self.getparam('year'))
self.filter &= Q(year=year)
row_id = self.get_max_row() + 1
lbl = XferCompLabelForm('title_year')
lbl.set_italic()
lbl.set_value("{[b]}%s{[/b]} : %s" % (_('fiscal year'), year))
lbl.set_location(1, row_id, 1)
self.add_component(lbl)
if self.getparam('cost_accounting') is not None:
cost = CostAccounting.objects.get(id=self.getparam('cost_accounting', 0))
self.filter &= Q(cost_accounting=cost)
row_id = self.get_max_row() + 1
lbl = XferCompLabelForm('title_cost')
lbl.set_italic()
lbl.set_value("{[b]}%s{[/b]} : %s" % (_('cost accounting'), cost))
lbl.set_location(1, row_id, 1)
self.add_component(lbl)
Signal.call_signal('editbudget', self)
def fillresponse_header(self):
status_filter = self.getparam('status_filter',
Expense.STATUS_BUILDING_WAITING)
self.params['status_filter'] = status_filter
date_filter = self.getparam('date_filter', 0)
self.fieldnames = Expense.get_default_fields(status_filter)
edt = XferCompSelect("status_filter")
edt.set_select(Expense.SELECTION_STATUS)
edt.set_value(status_filter)
edt.description = _('Filter by type')
edt.set_location(0, 3)
edt.set_action(self.request,
self.return_action(),
modal=FORMTYPE_REFRESH,
close=CLOSE_NO)
self.add_component(edt)
edt = XferCompSelect("date_filter")
edt.set_select([(0, _('only current fiscal year')),
(1, _('all expenses'))])
edt.set_value(date_filter)
edt.set_location(0, 4)
edt.description = _('Filter by date')
edt.set_action(self.request,
self.return_action(),
modal=FORMTYPE_REFRESH,
close=CLOSE_NO)
self.add_component(edt)
if status_filter == Expense.STATUS_BUILDING_WAITING:
self.filter = Q(status=Expense.STATUS_BUILDING) | Q(
status=Expense.STATUS_WAITING)
elif status_filter != Expense.STATUS_ALL:
self.filter = Q(status=status_filter)
else:
self.filter = Q()
if date_filter == 0:
current_year = FiscalYear.get_current()
self.filter &= Q(date__gte=current_year.begin) & Q(
date__lte=current_year.end)
def generate_accounting(self, third_amounts, designation=None):
supporting = self.supporting.get_final_child()
if self.supporting.is_revenu:
is_revenu = -1
else:
is_revenu = 1
fiscal_year = FiscalYear.get_current()
if designation is None:
designation = _("payoff for %s") % six.text_type(supporting)
new_entry = EntryAccount.objects.create(
year=fiscal_year, date_value=self.date, designation=designation,
journal=Journal.objects.get(id=4), costaccounting=supporting.default_costaccounting())
amount_to_bank = 0
for third, amount in third_amounts:
third_account = third.get_account(fiscal_year, supporting.get_third_mask())
if third_account.type_of_account == 0:
is_liability = 1
else:
is_liability = -1
EntryLineAccount.objects.create(account=third_account, amount=is_liability * is_revenu * amount, third=third, entry=new_entry)
amount_to_bank += float(amount)
if self.bank_account is None:
bank_code = Params.getvalue("payoff-cash-account")
else:
bank_code = self.bank_account.account_code
bank_account = ChartsAccount.get_account(bank_code, fiscal_year)
if bank_account is None:
raise LucteriosException(
IMPORTANT, _("account is not defined!"))
fee_code = Params.getvalue("payoff-bankcharges-account")
if (fee_code != '') and (float(self.bank_fee) > 0.001):
fee_account = ChartsAccount.get_account(fee_code, fiscal_year)
if fee_account is not None:
EntryLineAccount.objects.create(account=fee_account,
amount=-1 * is_revenu * float(self.bank_fee), entry=new_entry)
amount_to_bank -= float(self.bank_fee)
EntryLineAccount.objects.create(account=bank_account,
amount=-1 * is_revenu * amount_to_bank, entry=new_entry)
return new_entry
def get_filter(self):
if self.getparam('CRITERIA') is None:
select_year = self.getparam('year')
select_journal = self.getparam('journal', 4)
select_filter = self.getparam('filter', 1)
new_filter = Q(entry__year=FiscalYear.get_current(select_year))
if select_filter == 1:
new_filter &= Q(entry__close=False)
elif select_filter == 2:
new_filter &= Q(entry__close=True)
elif select_filter == 3:
new_filter &= Q(entry__link__id__gt=0)
elif select_filter == 4:
new_filter &= Q(entry__link=None)
if select_journal != -1:
new_filter &= Q(entry__journal__id=select_journal)
else:
self.item = EntryAccount()
entries = EntryAccount.objects.filter(XferPrintListing.get_filter(self))
self.item = EntryLineAccount()
new_filter = Q(entry_id__in=[entry.id for entry in entries])
return new_filter
def fillresponse_header(self):
status_filter = self.getparam('status_filter', -1)
year_filter = self.getparam('year_filter', FiscalYear.get_current().id)
lbl = XferCompLabelForm('lbl_statusfilter')
lbl.set_value_as_name(_('Filter by status'))
lbl.set_location(0, 1)
self.add_component(lbl)
dep_field = DepositSlip.get_field_by_name('status')
sel_list = list(dep_field.choices)
sel_list.insert(0, (-1, '---'))
edt = XferCompSelect("status_filter")
edt.set_select(sel_list)
edt.set_value(status_filter)
edt.set_needed(False)
edt.set_location(1, 1)
edt.set_action(self.request, self.get_action(), modal=FORMTYPE_REFRESH, close=CLOSE_NO)
self.add_component(edt)
lbl = XferCompLabelForm('lbl_yearfilter')
lbl.set_value_as_name(_('Filter by year'))
lbl.set_location(0, 2)
self.add_component(lbl)
edt = XferCompSelect("year_filter")
edt.set_needed(False)
edt.set_select_query(FiscalYear.objects.all())
edt.set_value(year_filter)
edt.set_location(1, 2)
edt.set_action(self.request, self.get_action(), modal=FORMTYPE_REFRESH, close=CLOSE_NO)
self.add_component(edt)
self.filter = Q()
if status_filter >= 0:
self.filter &= Q(status=status_filter)
if year_filter > 0:
year = FiscalYear.objects.get(id=year_filter)
self.filter &= Q(date__gte=year.begin)
self.filter &= Q(date__lte=year.end)
def check_account_config(self):
from diacamma.accounting.tools import current_system_account
try:
lettering_check = Params.getvalue(
"accounting-lettering-check").split('{[br/]}')
changed = False
new_lettering = []
for letter in lettering_check:
if match(current_system_account().get_third_mask(),
letter) is not None:
new_lettering.append(letter)
else:
changed = True
for account in ChartsAccount.objects.filter(
year=FiscalYear.get_current(),
code__regex=current_system_account().get_societary_mask()):
if account.code not in new_lettering:
new_lettering.append(account.code)
changed = True
if changed:
Params.setvalue("accounting-lettering-check",
'{[br/]}'.join(new_lettering))
except LucteriosException:
pass
def fill_header(self):
self.item = FiscalYear.get_current(self.getparam("year"))
new_begin = convert_date(self.getparam("begin"), self.item.begin)
new_end = convert_date(self.getparam("end"), self.item.end)
if (new_begin >= self.item.begin) and (new_end <= self.item.end):
self.item.begin = new_begin
self.item.end = new_end
img = XferCompImage('img')
img.set_value(self.icon_path())
img.set_location(0, 0, 1, 3)
self.add_component(img)
select_year = XferCompSelect(self.field_id)
select_year.set_location(1, 0, 4)
select_year.set_select_query(FiscalYear.objects.all())
select_year.set_value(self.item.id)
select_year.set_needed(True)
select_year.set_action(self.request, self.__class__.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
self.add_component(select_year)
self.filter = Q(entry__year=self.item)
if self.item.status != 2:
self.fill_from_model(1, 1, False, ['begin'])
self.fill_from_model(3, 1, False, ['end'])
begin_filter = self.get_components('begin')
begin_filter.set_action(self.request, self.__class__.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
end_filter = self.get_components('end')
end_filter.set_action(self.request, self.__class__.get_action(), close=CLOSE_NO, modal=FORMTYPE_REFRESH)
self.filter &= Q(entry__date_value__gte=self.item.begin)
self.filter &= Q(entry__date_value__lte=self.item.end)
self.fill_filterCode()
lbl = XferCompLabelForm("result")
lbl.set_value_center(self.item.total_result_text)
lbl.set_location(0, 6, 6)
self.add_component(lbl)
self.fill_filterheader()
self.define_gridheader()
def create_account(codes, type_of_account, year=None):
if year is None:
year = FiscalYear.get_current()
for code in codes:
ChartsAccount.objects.create(
code=code, name=code, type_of_account=type_of_account, year=year)
def default_bankaccount():
create_account(["581"], 0, FiscalYear.get_current())
BankAccount.objects.create(designation="My bank", reference="0123 456789 321654 12", account_code="512")
BankAccount.objects.create(designation="PayPal", reference="*****@*****.**", account_code="581")
def finalize_year_after_condo(xfer):
year = FiscalYear.get_current(xfer.getparam('year'))
if year is not None:
year.set_context(xfer)
generate_pdfreport(year)
def fillresponse(self, year):
fiscal_year = FiscalYear.get_current(year)
read_only = (fiscal_year.status == 2)
self.redirect_action(BudgetList.get_action(), close=CLOSE_YES, params={'year': fiscal_year.id, 'readonly': read_only})
def get_info_state(self, third_mask=None):
info = []
if third_mask is None:
third_mask = self.get_third_mask()
if self.status == 0:
if self.third is None:
info.append(six.text_type(_("no third selected")))
else:
accounts = self.third.accountthird_set.filter(
code__regex=third_mask)
try:
if (len(accounts) == 0) or (ChartsAccount.get_account(accounts[0].code, FiscalYear.get_current()) is None):
info.append(
six.text_type(_("third has not correct account")))
except LucteriosException as err:
info.append(six.text_type(err))
return info
def fillresponse(self, confirme):
account_list = []
signal_and_lock.Signal.call_signal("initial_account", account_list)
if self.confirme(_('Do you want to import initial accounts?')):
ChartsAccount.import_initial(FiscalYear.get_current(self.getparam('year')), account_list)
