def get_post(self, request, *args, **kwargs): getLogger("lucterios.core.request").debug( ">> get %s [%s]", request.path, request.user) try: self._initialize(request, *args, **kwargs) full_path = join( get_user_dir(), six.text_type(self.getparam('filename'))) if not isfile(full_path): raise LucteriosException(IMPORTANT, _("File not found!")) sign = self.getparam('sign', '') if sign != md5sum(full_path): raise LucteriosException(IMPORTANT, _("File invalid!")) content_type, encoding = mimetypes.guess_type(full_path) content_type = content_type or 'application/octet-stream' statobj = os.stat(full_path) response = StreamingHttpResponse(open(full_path, 'rb'), content_type=content_type) response["Last-Modified"] = http_date(statobj.st_mtime) if stat.S_ISREG(statobj.st_mode): response["Content-Length"] = statobj.st_size if encoding: response["Content-Encoding"] = encoding return response finally: getLogger("lucterios.core.request").debug( "<< get %s [%s]", request.path, request.user)
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_report(self, request, is_csv): report_content = self.generate(request) if is_csv: xsl_file = join(dirname(__file__), "ConvertxlpToCSV.xsl") if not isfile(xsl_file): raise LucteriosException(GRAVE, "Error:no csv xsl file!") with open(xsl_file, 'rb') as xsl_file: csv_transform = etree.XSLT(etree.XML(xsl_file.read())) xml_rep_content = etree.XML(report_content) for xml_br in xml_rep_content.xpath("//br"): xml_br.text = ',' content = six.text_type( csv_transform(xml_rep_content)).encode('utf-8') else: try: content = transforme_xml2pdf(report_content, self.watermark) except ValueError: getLogger("lucterios.core.print").exception( 'transforme_xml2pdf') raise LucteriosException(IMPORTANT, _('This impression failed !')) if len(content) > 0: return content else: return ""
def fillresponse(self): if self.item.folder is not None and notfree_mode_connect( ) and not self.request.user.is_superuser: if self.item.folder.cannot_view(self.request.user): raise LucteriosException(IMPORTANT, _("No allow to view!")) if self.item.folder.is_readonly(self.request.user): raise LucteriosException(IMPORTANT, _("No allow to write!")) XferAddEditor.fillresponse(self)
def fillresponse(self, oldpass='', newpass1='', newpass2=''): if not self.request.user.check_password(oldpass): raise LucteriosException(IMPORTANT, _("Bad current password!")) if newpass1 != newpass2: raise LucteriosException(IMPORTANT, _("The passwords are differents!")) self.request.user.set_password(newpass1) self.request.user.save() self.message(_("Password modify"), XFER_DBOX_INFORMATION)
def _get(cls, name): if name not in cls._PARAM_CACHE_LIST.keys(): try: cls._PARAM_CACHE_LIST[name] = ParamCache(name) except ObjectDoesNotExist: raise LucteriosException(GRAVE, "Parameter %s unknown!" % name) except Exception: raise LucteriosException(GRAVE, "Parameter %s not found!" % name) return cls._PARAM_CACHE_LIST[name]
def fillresponse(self): folder = None if len(self.items) > 0: folder = self.items[0].folder if folder is not None and notfree_mode_connect( ) and not self.request.user.is_superuser: if folder.cannot_view(self.request.user): raise LucteriosException(IMPORTANT, _("No allow to view!")) if folder.is_readonly(self.request.user): raise LucteriosException(IMPORTANT, _("No allow to write!")) XferDelete.fillresponse(self)
def before_save(self, xfer): date = xfer.getparam('begin_date') if date is None: raise LucteriosException(IMPORTANT, _("date invalid!")) date = convert_date(date) new_season = "%d/%d" % (date.year, date.year + 1) if len( Season.objects.filter(designation=new_season).exclude( id=self.item.id)) > 0: raise LucteriosException(IMPORTANT, _("Season exists yet!")) self.item.designation = new_season self.item.iscurrent = False
def _search_model(self): if self.model is None: raise LucteriosException(GRAVE, _("No model")) if isinstance(self.field_id, tuple): for field_id in self.field_id: ids = self.getparam(field_id) if ids is not None: self.field_id = field_id break else: ids = self.getparam(self.field_id) if ids is None: raise LucteriosException(GRAVE, _("No selection")) ids = ids.split(';') self.items = self.model.objects.filter(pk__in=ids).distinct()
def _search_model(self): self.model = Payoff ids = self.getparam(self.field_id) if ids is None: raise LucteriosException(GRAVE, _("No selection")) ids = ids.split(';') self.items = Payoff.objects.filter(entry_id__in=ids).distinct()
def lock(cls, request, model_item): logging.getLogger("lucterios.core.record").debug(">> lock [%s] %s", request.user, model_item) cls._lock.acquire() try: params = {} from django.conf import settings session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME) if session_key is not None: lock_ident = "-".join((six.text_type(model_item.__module__), six.text_type(model_item.__class__.__name__), six.text_type(model_item.pk))) params['LOCK_IDENT'] = lock_ident if lock_ident in cls._lock_list.keys(): old_session_key = cls._lock_list[lock_ident] if old_session_key != session_key: try: old_session = LucteriosSession.objects.get(pk=old_session_key) if old_session.get_is_active(): raise LucteriosException(IMPORTANT, _("Record locked by '%s'!") % old_session.username) else: del cls._lock_list[lock_ident] old_session.flush() except ObjectDoesNotExist: pass cls._lock_list[lock_ident] = session_key return params finally: cls._lock.release() logging.getLogger("lucterios.core.record").debug("<< lock [%s] %s %s", request.user, model_item, session_key)
def _read_csv(self): if self.quotechar == '': current_quoting = QUOTE_NONE else: current_quoting = QUOTE_ALL if 'csvcontent' in self.request.FILES.keys(): csvfile = TextIOWrapper( self.request.FILES['csvcontent'].file, encoding=self.encoding, errors='replace') csvcontent = "".join(csvfile.readlines()) for param_idx in range(0, int(len(csvcontent) / 2048) + 2): self.params['csvcontent%d' % param_idx] = csvcontent[ 2048 * param_idx:2048 * (param_idx + 1)] csvfile.seek(0) else: csvcontent = "" for param_idx in range(0, 1000): curent_content = self.getparam('csvcontent%d' % param_idx) if curent_content is None: break else: csvcontent += "" + curent_content csvfile = StringIO(csvcontent) self.spamreader = DictReader(csvfile, delimiter=self.delimiter, quotechar=self.quotechar, quoting=current_quoting) try: if (self.spamreader.fieldnames is None) or (len(self.spamreader.fieldnames) == 0): raise Exception("") except Exception: raise LucteriosException(IMPORTANT, _('CSV file unvalid!'))
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(self): if (self.item.id is None) and hasattr(settings, "DIACAMMA_MAXOWNER"): nb_owner = len(Owner.objects.all()) if getattr(settings, "DIACAMMA_MAXOWNER") <= nb_owner: raise LucteriosException(IMPORTANT, _('You have the maximum of owners!')) XferAddEditor.fillresponse(self)
def fillresponse(self): try: Responsability.objects.get(individual__user=self.request.user, legal_entity=self.item) LegalEntityAddModify.fillresponse(self) except Exception: raise LucteriosException(IMPORTANT, _("Bad access!"))
def get_print_selector(cls, kind, model): selection = [] for dblbl in cls.objects.filter(kind=kind, modelname=model.get_long_name()): selection.append((dblbl.id, dblbl.name)) if len(selection) == 0: raise LucteriosException(IMPORTANT, _('No model!')) return [('MODEL', _('model'), selection)]
def get_print_default(cls, kind, model, raiseerror=True): models = cls.objects.filter(kind=kind, modelname=model.get_long_name(), is_default=True) if len(models) > 0: return models[0].id if raiseerror: raise LucteriosException(IMPORTANT, _('No default model for %s!') % model._meta.verbose_name) return 0
def delete(self, using=None): try: models.Model.delete(self, using=using) except ProtectedError: logging.getLogger('lucterios.framwork').debug("delete", exc_info=True) raise LucteriosException(IMPORTANT, _( 'Cannot delete this record: there are associated with some sub-record'))
def saving(self, xfer): password = None password_generate = xfer.getparam('password_generate') password_change = xfer.getparam('password_change') if password_generate == 'o': if not self.item.generate_password(): raise LucteriosException(MINOR, _("The password is not changed!")) elif password_change == 'o': password = xfer.getparam('password1') password_again = xfer.getparam('password2') if password != password_again: raise LucteriosException(IMPORTANT, _("The passwords are differents!")) self.item.set_password(password) self.item.save()
def fillresponse(self): if not will_mail_send(): raise LucteriosException(IMPORTANT, _('Bad email parameter!')) legal = LegalEntity.objects.get(id=1) if self.getparam('CONFIRME') is None: dlg = self.create_custom() img = XferCompImage('img') img.set_value(self.icon_path()) img.set_location(0, 0, 1, 3) dlg.add_component(img) lbl = XferCompLabelForm('lbl_title') lbl.set_location(1, 0, 2) lbl.set_value_as_header(self.caption) dlg.add_component(lbl) email = XferCompEdit('recipient') email.set_location(1, 1) email.set_value(legal.email) email.mask = r"[^@]+@[^@]+\.[^@]+" email.description = _("email") dlg.add_component(email) dlg.add_action(self.get_action(TITLE_OK, "images/ok.png"), close=CLOSE_YES, params={'CONFIRME': 'YES'}) dlg.add_action(WrapAction(TITLE_CANCEL, 'images/cancel.png')) else: address = [] address.append("") address.append("") address.append(six.text_type(legal)) address.append(legal.address) address.append("%s %s" % (legal.postal_code, legal.city)) message = _('EMail sent to check configuration') message += "{[br/]}".join(address).replace('{[newline]}', "{[br/]}").replace("\n", '{[br/]}') bad_sended = send_email(self.getparam('recipient'), _("EMail try"), "<html><body>%s</body></html>" % message.replace('{[', '<').replace(']}', '>')) if len(bad_sended) != 0: raise EmailException(bad_sended) self.message(_("EMail send, check it."))
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 fillresponse(self): if (self.item.id is None) and hasattr(settings, "DIACAMMA_MAXACTIVITY"): nb_act = len(Activity.objects.all()) if getattr(settings, "DIACAMMA_MAXACTIVITY") <= nb_act: raise LucteriosException( IMPORTANT, _('You have the maximum of activities!')) XferAddEditor.fillresponse(self)
def fillresponse(self, begin_date, end_date): owners = get_owners(self.request) if len(owners) != 1: raise LucteriosException(IMPORTANT, _('Bad access!')) self.item = owners[0] self.params['owner'] = self.item.id OwnerShow.fillresponse(self, begin_date, end_date) self.add_action(CurrentOwnePrint.get_action(TITLE_PRINT, "images/print.png"), close=CLOSE_NO, pos_act=0)
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 fillresponse(self): parent = None if len(self.items) > 0: parent = self.items[0].parent if not WrapAction.is_permission(self.request, 'documents.delete_folder'): for item in self.items: if isinstance(item.get_final_child(), FolderContainer): raise LucteriosException(IMPORTANT, _("No allow to delete folder!")) if parent is not None and notfree_mode_connect( ) and not self.request.user.is_superuser: if parent.cannot_view(self.request.user): raise LucteriosException(IMPORTANT, _("No allow to view!")) if parent.is_readonly(self.request.user): raise LucteriosException(IMPORTANT, _("No allow to write!")) XferDelete.fillresponse(self)
def fillresponse(self): transition = self.getparam('TRANSITION', '') if transition in self.trans_list: trans = self.trans_list[transition] self.caption = trans[5] self.fill_confirm(transition, trans) else: raise LucteriosException(GRAVE, _("Bad transition"))
def items_callback(self): has_item = False for item in self.items: if item.status != CallFunds.STATUS_BUILDING: has_item = True yield item if not has_item: raise LucteriosException(IMPORTANT, _("No call of funds to print!"))
def docshow_modify_condition(xfer): if xfer.item.folder is not None and notfree_mode_connect( ) and not xfer.request.user.is_superuser: if xfer.item.folder.cannot_view(xfer.request.user): raise LucteriosException(IMPORTANT, _("No allow to view!")) if xfer.item.folder.is_readonly(xfer.request.user): return False return True
def folder_notreadonly_condition(xfer, gridname=''): if notfree_mode_connect() and not xfer.request.user.is_superuser: if xfer.current_folder > 0: folder = FolderContainer.objects.get(id=xfer.current_folder) if folder.cannot_view(xfer.request.user): raise LucteriosException(IMPORTANT, _("No allow to view!")) if folder.is_readonly(xfer.request.user): return False return True
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()