def generate_revenue_for_expense(self, expense, is_asset, fiscal_year): if Params.getvalue("condominium-old-accounting"): for detail in expense.expensedetail_set.all(): self._generate_revenue_for_expense_oldaccounting(detail, is_asset, fiscal_year) elif len(expense.expensedetail_set.filter(set__type_load=1)) > 0: total = 0 revenue_code = Params.getvalue("condominium-exceptional-revenue-account") revenue_account = ChartsAccount.get_account(revenue_code, fiscal_year) if revenue_account is None: raise LucteriosException(IMPORTANT, _("code account %s unknown!") % revenue_code) reserve_code = Params.getvalue("condominium-exceptional-reserve-account") reserve_account = ChartsAccount.get_account(reserve_code, fiscal_year) if revenue_account is None: raise LucteriosException(IMPORTANT, _("code account %s unknown!") % reserve_code) new_entry = EntryAccount.objects.create(year=fiscal_year, date_value=expense.expense.date, designation=expense.__str__(), journal=Journal.objects.get(id=3)) for detail in expense.expensedetail_set.all(): detail.generate_ratio(is_asset) if detail.set.type_load == 1: cost_accounting = detail.set.current_cost_accounting price = currency_round(detail.price) EntryLineAccount.objects.create(account=revenue_account, amount=is_asset * price, entry=new_entry, costaccounting=cost_accounting) total += price detail.entry = new_entry detail.save() EntryLineAccount.objects.create(account=reserve_account, amount=-1 * is_asset * total, entry=new_entry) no_change, debit_rest, credit_rest = new_entry.serial_control(new_entry.get_serial()) if not no_change or (abs(debit_rest) > 0.001) or (abs(credit_rest) > 0.001): raise LucteriosException(GRAVE, _("Error in accounting generator!") + "{[br/]} no_change=%s debit_rest=%.3f credit_rest=%.3f" % (no_change, debit_rest, credit_rest))
def generate_entry(self): if self.bill_type == 2: is_bill = -1 else: is_bill = 1 third_account = self.get_third_account( current_system_account().get_customer_mask(), self.fiscal_year) self.entry = EntryAccount.objects.create( year=self.fiscal_year, date_value=self.date, designation=self.__str__(), journal=Journal.objects.get(id=3), costaccounting=self.cost_accounting) EntryLineAccount.objects.create( account=third_account, amount=is_bill * self.get_total_incltax(), third=self.third, entry=self.entry) remise_total = 0 detail_list = {} for detail in self.detail_set.all(): if detail.article is not None: detail_code = detail.article.sell_account else: detail_code = Params.getvalue("invoice-default-sell-account") detail_account = ChartsAccount.get_account( detail_code, self.fiscal_year) if detail_account is None: raise LucteriosException( IMPORTANT, _("article has code account unknown!")) if detail_account.id not in detail_list.keys(): detail_list[detail_account.id] = [detail_account, 0] detail_list[detail_account.id][ 1] += detail.get_total_excltax() + detail.get_reduce_excltax() remise_total += detail.get_reduce_excltax() if remise_total > 0.001: remise_code = Params.getvalue("invoice-reduce-account") remise_account = ChartsAccount.get_account( remise_code, self.fiscal_year) if remise_account is None: raise LucteriosException( IMPORTANT, _("reduce-account is not defined!")) EntryLineAccount.objects.create( account=remise_account, amount=-1 * is_bill * remise_total, entry=self.entry) for detail_item in detail_list.values(): EntryLineAccount.objects.create( account=detail_item[0], amount=is_bill * detail_item[1], entry=self.entry) if self.get_vta_sum() > 0.001: vta_code = Params.getvalue("invoice-vatsell-account") vta_account = ChartsAccount.get_account( vta_code, self.fiscal_year) if vta_account is None: raise LucteriosException( IMPORTANT, _("vta-account is not defined!")) EntryLineAccount.objects.create( account=vta_account, amount=is_bill * self.get_vta_sum(), entry=self.entry) no_change, debit_rest, credit_rest = self.entry.serial_control( self.entry.get_serial()) if not no_change or (abs(debit_rest) > 0.001) or (abs(credit_rest) > 0.001): raise LucteriosException( GRAVE, _("Error in accounting generator!") + "{[br/]} no_change=%s debit_rest=%.3f credit_rest=%.3f" % (no_change, debit_rest, credit_rest))
def _generate_account_callfunds_by_type(self, new_entry, type_call, calldetails): detail_account_filter = None if type_call == 0: detail_account_filter = Params.getvalue( "condominium-current-revenue-account") if type_call == 1: detail_account_filter = Params.getvalue( "condominium-exceptional-revenue-account") if type_call == 2: detail_account_filter = Params.getvalue( "condominium-advance-revenue-account") if type_call == 4: detail_account_filter = Params.getvalue( "condominium-fundforworks-revenue-account") detail_account = ChartsAccount.get_account(detail_account_filter, new_entry.year) if detail_account is None: raise LucteriosException(IMPORTANT, _("incorrect account for call of found")) total = 0 for calldetail in calldetails: EntryLineAccount.objects.create( account=detail_account, amount=calldetail.price, entry=new_entry, costaccounting=calldetail.set.current_cost_accounting) total += calldetail.price calldetail.entry = new_entry calldetail.save() return total
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 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 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_third_account(self, third_mask, fiscalyear, third=None): if third is None: third = self.third accounts = third.accountthird_set.filter(code__regex=third_mask) if len(accounts) == 0: raise LucteriosException( IMPORTANT, _("third has not correct account")) third_account = ChartsAccount.get_account( accounts[0].code, fiscalyear) if third_account is None: raise LucteriosException( IMPORTANT, _("third has not correct account")) return third_account
def ventilate_result(self, fiscal_year, ventilate): Owner.throw_not_allowed() self.check_account_config() result = fiscal_year.total_revenue - fiscal_year.total_expense if abs(result) > 0.001: total_part = PropertyLot.get_total_part() if total_part > 0: close_entry = EntryAccount( year=fiscal_year, designation=_("Ventilation for %s") % fiscal_year.toText, journal_id=5) close_entry.check_date() close_entry.save() if ventilate == 0: amount = 0 biggerowner_val = 0 biggerowner_line = None for owner in Owner.objects.all(): total = owner.propertylot_set.aggregate( sum=Sum('value')) if ('sum' in total.keys()) and (total['sum'] is not None): value = currency_round(result * total['sum'] / total_part) if abs(value) > 0.0001: owner_account = owner.third.get_account( fiscal_year, owner.get_third_mask(1)) last_line = EntryLineAccount.objects.create( account=owner_account, amount=-1 * value, entry=close_entry, third=owner.third) if biggerowner_val < total['sum']: biggerowner_val = total['sum'] biggerowner_line = last_line amount += value diff = currency_round(result - amount) if abs(diff) > 0.0001: biggerowner_line.amount -= diff biggerowner_line.save() else: EntryLineAccount.objects.create(account_id=ventilate, amount=result, entry=close_entry) reserve_account = ChartsAccount.get_account( Params.getvalue("condominium-current-revenue-account"), fiscal_year) EntryLineAccount.objects.create(account=reserve_account, amount=-1 * result, entry=close_entry) close_entry.closed()
def generate_expense_for_expense(self, expense, is_asset, fiscal_year): third_account = expense.get_third_account(current_system_account().get_provider_mask(), fiscal_year) new_entry = EntryAccount.objects.create(year=fiscal_year, date_value=expense.date, designation=expense.__str__(), journal=Journal.objects.get(id=2)) total = 0 for detail in expense.expensedetail_set.all(): detail_account = ChartsAccount.get_account(detail.expense_account, fiscal_year) if detail_account is None: raise LucteriosException(IMPORTANT, _("code account %s unknown!") % detail.expense_account) price = currency_round(detail.price) EntryLineAccount.objects.create(account=detail_account, amount=is_asset * price, entry=new_entry, costaccounting_id=detail.set.current_cost_accounting.id) total += price EntryLineAccount.objects.create(account=third_account, amount=is_asset * total, third=expense.third, entry=new_entry) no_change, debit_rest, credit_rest = new_entry.serial_control(new_entry.get_serial()) if not no_change or (abs(debit_rest) > 0.001) or (abs(credit_rest) > 0.001): raise LucteriosException(GRAVE, _("Error in accounting generator!") + "{[br/]} no_change=%s debit_rest=%.3f credit_rest=%.3f" % (no_change, debit_rest, credit_rest)) expense.entries.set(EntryAccount.objects.filter(id=new_entry.id))
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 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 _generate_revenue_for_expense_oldaccounting(self, expense_detail, is_asset, fiscal_year): revenue_code = expense_detail.set.revenue_account cost_accounting = expense_detail.set.current_cost_accounting revenue_account = ChartsAccount.get_account(revenue_code, fiscal_year) if revenue_account is None: raise LucteriosException(IMPORTANT, _("code account %s unknown!") % revenue_code) price = currency_round(expense_detail.price) new_entry = EntryAccount.objects.create(year=fiscal_year, date_value=expense_detail.expense.date, designation=expense_detail.__str__(), journal=Journal.objects.get(id=3)) EntryLineAccount.objects.create(account=revenue_account, amount=is_asset * price, entry=new_entry, costaccounting=cost_accounting) for ratio in expense_detail.expenseratio_set.all(): third_account = expense_detail.expense.get_third_account(current_system_account().get_societary_mask(), fiscal_year, ratio.owner.third) EntryLineAccount.objects.create(account=third_account, amount=ratio.value, entry=new_entry, third=ratio.owner.third) no_change, debit_rest, credit_rest = new_entry.serial_control(new_entry.get_serial()) if not no_change or (abs(debit_rest) > 0.001) or (abs(credit_rest) > 0.001): raise LucteriosException(GRAVE, _("Error in accounting generator!") + "{[br/]} no_change=%s debit_rest=%.3f credit_rest=%.3f" % (no_change, debit_rest, credit_rest)) expense_detail.entry = new_entry expense_detail.save()
def convert_query_to_account(query1, query2=None, query_budget=None): total1 = 0 total2 = None total3 = None dict_account = {} for data_line in EntryLineAccount.objects.filter(query1).values('account').annotate(data_sum=Sum('amount')): account = ChartsAccount.objects.get(id=data_line['account']) if abs(data_line['data_sum']) > 0.0001: dict_account[correct_accounting_code(account.code)] = [account.get_name(), format_devise(data_line['data_sum'], 5), None, None] total1 += data_line['data_sum'] if query2 is not None: total2 = 0 for data_line in EntryLineAccount.objects.filter(query2).values('account').annotate(data_sum=Sum('amount')): account = ChartsAccount.objects.get(id=data_line['account']) if abs(data_line['data_sum']) > 0.0001: account_code = correct_accounting_code(account.code) if account_code not in dict_account.keys(): dict_account[account_code] = [account.get_name(), None, 0, None] dict_account[account_code][2] = format_devise(data_line['data_sum'], 5) total2 += data_line['data_sum'] if query_budget is not None: total3 = 0 for data_line in Budget.objects.filter(query_budget).values('code').annotate(data_sum=Sum('amount')): if abs(data_line['data_sum']) > 0.0001: account_code = correct_accounting_code(data_line['code']) if account_code not in dict_account.keys(): account = ChartsAccount.get_chart_account(account_code) dict_account[account_code] = [account.get_name(), None, None, 0] dict_account[account_code][3] = format_devise(data_line['data_sum'], 5) total3 += data_line['data_sum'] res = [] keys = list(dict_account.keys()) keys.sort() for key in keys: res.append(dict_account[key]) return res, total1, total2, total3
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Lucterios. If not, see <http://www.gnu.org/licenses/>. """ from __future__ import unicode_literals from django.utils.translation import ugettext_lazy as _ from diacamma.accounting.models import ChartsAccount name = _("listing") kind = 0 modelname = ChartsAccount.get_long_name() value = """210 297 10//%s//#code 25//%s//#name 15//%s//#last_year_total 15//%s//#current_total 15//%s//#current_validated """ % ( _("code"), _("name"), _("total of last year"), _("total current"), _("total validated"), )
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)
def __init__(self, **kwargs): ObjectMerge.__init__(self, **kwargs) self.params['modelname'] = ChartsAccount.get_long_name()