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()
