def _trainer_datas_links(self):
result = []
for user in self.context.employees:
if not self.request.has_permission('edit.trainerdatas', user):
# Je ne peux pas éditer les infos formateurs de mes collègues
continue
if user.id == self.request.user.id:
label = u"Voir ma fiche formateur"
else:
label = u"Voir la fiche formateur de {}".format(
format_account(user)
)
result.append(
Link(
self.request.route_path(
USER_TRAINER_EDIT_URL,
id=user.id
),
label,
icon="fa fa-search",
popup=True,
css='btn btn-default',
)
)
return result
def title(self):
if self.is_my_account_view():
return u"Modification de mon mot de passe"
else:
return u"Modification du mot de passe de {0}".format(
format_account(self.current().user)
)
def libelle(self):
return self.label_template.format(
beneficiaire=format_account(self.expense.user, reverse=False),
beneficiaire_LASTNAME=self.expense.user.lastname.upper(),
expense=self.expense,
expense_date=UnicodeDate(self.expense.year, self.expense.month, 1)
)
def libelle(self):
return self.label_template.format(
beneficiaire=format_account(self.expense.user, reverse=False),
beneficiaire_LASTNAME=self.expense.user.lastname.upper(),
expense=self.expense,
expense_date=datetime.date(self.expense.year, self.expense.month,
1))
def check(self, expenses):
"""
Check if we can export the expenses
:param expenses: the expenses to export
:returns: a 2-uple (is_ok, messages)
"""
count = expenses.count()
if count == 0:
title = u"Il n'y a aucune note de dépense à exporter"
res = {'title': title, 'errors': []}
return False, res
title = u"Vous vous apprêtez à exporter {0} notes de dépense".format(
count)
errors = []
if not self._check_config(self.request.config):
url1 = self.request.route_path(EXPENSE_ACCOUNTING_URL)
url2 = self.request.route_path(ACCOUNTING_URL)
errors.append(CONFIG_ERROR_MSG.format(url1, url2))
for expense in expenses:
company = expense.company
error = self._check_company(company)
if error is not None:
errors.append(
u"La note de dépense de {0} n'est pas exportable "
u"<br />{1}".format(strings.format_account(expense.user),
error))
res = {'title': title, 'errors': errors}
return len(errors) == 0, res
def title(self):
if self.is_my_account_view():
return u"Modification de mes identifiants"
else:
return u"Modification des identifiants de {0}".format(
format_account(self.current().user)
)
def subject(self):
"""
return the subject of the email
"""
subject = u"Notes de dépense de {0} : {1}".format(
format_account(self.expense.user),
self.format_expense_notification())
return subject
def format_expense_notification(self):
"""
Return a formatted string for expense status notification
"""
status_str = EXPENSE_NOTIFY_STATUS.get(self.new_status)
account_label = format_account(self.request.user)
date_label = format_date(datetime.date.today())
return status_str.format(account_label, date_label)
def subject(self):
"""
return the subject of the email
"""
subject = u"Notes de dépense de {0} : {1}".format(
format_account(self.event.node.user),
self.format_expense_notification()
)
return subject
def __call__(self):
path_query = CareerPath.query(self.current_userdatas.id)
path_query = path_query.options(
Load(CareerPath).load_only("start_date", "id"),
joinedload("career_stage").load_only("name"),
)
return dict(career_path=path_query.all(),
user=self.current_userdatas.user,
title=u"Parcours de {0}".format(
format_account(self.current_userdatas.user, False)))
def format_expense_notification(self):
"""
Return a formatted string for expense status notification
"""
status_str = EXPENSE_NOTIFY_STATUS.get(self.event.status)
account_label = format_account(self.request.user)
date_label = format_date(datetime.date.today())
if status_str != None:
return status_str.format(account_label, date_label)
else:
return ""
def body(self):
"""
return the body of the email
"""
status_verb = get_status_verb(self.status)
# If the document is validated, we directly send the link to the pdf
# file
if self.status == 'valid':
query_args = dict(view="pdf")
else:
query_args = {}
addr = self.request.route_url(
"/%ss/{id}.html" % self.event.node.type_,
id=self.event.node.id,
_query=query_args,
)
addr = format_link(self.settings, addr)
docnumber = self.event.node.internal_number.lower()
customer = self.event.node.customer.label
project = self.event.node.project.name.capitalize()
if self.event.node.type_ == 'invoice':
docname = u"La facture"
gender = u"e"
determinant = u"la"
elif self.event.node.type_ == 'cancelinvoice':
docname = u"L'avoir"
gender = u""
determinant = u"le"
else:
docname = u"Le devis"
gender = u""
determinant = u"le"
if self.event.node.status_comment:
comment = self.event.node.status_comment
else:
comment = u"Aucun"
username = format_account(self.event.node.owner, reverse=False)
return MAIL_TMPL.format(
determinant=determinant,
username=username,
docname=docname,
docnumber=docnumber,
customer=customer,
project=project,
status_verb=status_verb,
gender=gender,
addr=addr,
comment=comment)
def __call__(self):
path_query = CareerPath.query(self.current_userdatas.id)
path_query = path_query.options(
Load(CareerPath).load_only("start_date", "id"),
joinedload("career_stage").load_only("name"),
)
return dict(
career_path=path_query.all(),
user=self.current_userdatas.user,
title=u"Parcours de {0}".format(
format_account(self.current_userdatas.user, False)
)
)
def body(self):
"""
return the body of the email
"""
owner = format_account(self.event.node.user)
date = u"{0}/{1}".format(self.event.node.month, self.event.node.year)
status_verb = get_status_verb(self.event.status)
addr = self.request.route_url("/expenses/{id}", id=self.event.node.id)
addr = format_link(self.settings, addr)
return MAIL_TMPL.format(
owner=owner,
addr=addr,
date=date,
status_verb=status_verb,
comment=self.event.comment,
)
def body(self):
"""
return the body of the email
"""
owner = format_account(self.expense.user)
date = u"{0}/{1}".format(self.expense.month, self.expense.year)
status_verb = get_status_verb(self.new_status)
addr = self.request.route_url("/expenses/{id}", id=self.expense.id)
addr = format_link(self.settings, addr)
return MAIL_TMPL.format(
owner=owner,
addr=addr,
date=date,
status_verb=status_verb,
comment=self.comment,
)
def _trainer_datas_links(self):
result = []
for user in self.context.employees:
if not self.request.has_permission('edit.trainerdatas', user):
# Je ne peux pas éditer les infos formateurs de mes collègues
continue
if user.id == self.request.user.id:
label = u"Voir ma fiche formateur"
else:
label = u"Voir la fiche formateur de {}".format(
format_account(user))
result.append(
Link(
self.request.route_path(USER_TRAINER_EDIT_URL, id=user.id),
label,
icon="fa fa-search",
popup=True,
css='btn btn-default',
))
return result
def check(self, expenses):
"""
Check if we can export the expenses
:param expenses: the expenses to export
:returns: a 2-uple (is_ok, messages)
"""
count = expenses.count()
if count == 0:
title = u"Il n'y a aucune note de dépense à exporter"
res = {
'title': title,
'errors': []
}
return False, res
title = u"Vous vous apprêtez à exporter {0} notes de dépense".format(
count)
errors = []
if not self._check_config(self.request.config):
url1 = self.request.route_path(EXPENSE_ACCOUNTING_URL)
url2 = self.request.route_path(ACCOUNTING_URL)
errors.append(CONFIG_ERROR_MSG.format(url1, url2))
for expense in expenses:
company = expense.company
error = self._check_company(company)
if error is not None:
errors.append(
u"La note de dépense de {0} n'est pas exportable "
u"<br />{1}".format(
strings.format_account(expense.user),
error
)
)
res = {'title': title, 'errors': errors}
return len(errors) == 0, res
def get_users_options(roles=None):
"""
Return the list of active users from the database formatted as choices:
[(user_id, user_label)...]
:param role: roles of the users we want
default: all
values : ('contractor', 'manager', 'admin'))
"""
query = DBSESSION().query(User).options(
load_only('id', 'firstname', 'lastname'))
# Only User accounts with logins
query = query.join(Login).filter(Login.active == True)
query = query.order_by(User.lastname)
if roles and not hasattr(roles, "__iter__"):
roles = [roles]
query = _filter_by_group(query, roles)
return [(unicode(u.id), format_account(u)) for u in query]
def _confirmation_form(self, query, appstruct, query_count):
"""
Return datas used to display a confirmation form
:param obj query: homonym SQLAlchemy query object
:param dict appstruct: Preserved form datas
:param int query_count: The number of homonyms
:returns: template vars
:rtype: dict
"""
if query_count == 1:
msg = u"Un compte similaire \
a déjà été créé: <ul>"
else:
msg = u"{0} comptes similaires ont \
déjà été créés : <ul>".format(query_count)
for entry in query:
msg += u"<li><a href='%s'>%s (%s)</a></li>" % (
self.request.route_path(USER_ITEM_URL, id=entry.id),
format_account(entry),
entry.email,
)
msg += u"</ul>"
form = self._get_form()
_query = self.request.GET.copy()
_query['confirmation'] = '1'
form.action = self.request.current_route_path(_query=_query)
form.set_appstruct(appstruct)
datas = dict(
form=form.render(),
confirmation_message=msg,
confirm_form_id=form.formid,
)
datas.update(self._more_template_vars())
return datas
def get_users_options(roles=None):
"""
Return the list of active users from the database formatted as choices:
[(user_id, user_label)...]
:param role: roles of the users we want
default: all
values : ('contractor', 'manager', 'admin'))
"""
query = DBSESSION().query(User).options(
load_only('id', 'firstname', 'lastname')
)
# Only User accounts with logins
query = query.join(Login).filter(Login.active == True)
query = query.order_by(User.lastname)
if roles and not hasattr(roles, "__iter__"):
roles = [roles]
query = _filter_by_group(query, roles)
return [(unicode(u.id), format_account(u)) for u in query]
def _stream_actions(self, item):
"""
Stream actions available for the given item
:param obj item: The company instance
"""
yield Link(
self.request.route_path(
"company",
id=item.id,
),
u"Voir",
title=u"Voir l'enseigne",
icon="search",
)
if self.request.has_permission('edit.company', item):
yield Link(
self.request.route_path(
"company",
id=item.id,
),
u"Modifier",
title=u"Modifier les informations relatives à l'enseigne",
icon="pencil",
)
if self.request.has_permission("admin.company"):
if len(item.employees) > 1:
yield Link(
self.request.route_path("company",
id=item.id,
_query={
'action': 'remove',
id: self.current_user.id
}),
u"Retirer",
title=u"Retirer l'entrepreneur de cette enseigne",
icon="link",
css="text-warning",
confirm=u"{} n'aura plus accès aux données de cette "
u"l'enseigne {}. Êtes-vous sûr de vouloir continuer "
u"?".format(format_account(self.current_user), item.name))
if item.active:
yield Link(
self.request.route_path("company",
id=item.id,
_query={'action': 'disable'}),
u"Désactiver",
title=u"Désactiver cette enseigne",
icon="book",
css="text-danger",
confirm=u"L'enseigne {} ne sera plus accessible et "
u"n'apparaîtra plus dans les listes (factures, notes de "
u"dépenses ...) Êtes-vous sûr de vouloir continuer "
u"?".format(item.name))
else:
yield Link(self.request.route_path("company",
id=item.id,
_query={'action':
'enable'}),
u"Activer",
title=u"Ré-activer cette enseigne",
icon="book",
css="text-success")
def title(self):
return u"Fiche formateur de {0}".format(
format_account(self.current_trainerdatas.user))
def title(self):
return u"Fiche de gestion sociale de {0}".format(
format_account(self.current_userdatas.user, False)
)
def title(self):
return u"Fiche formateur de {0}".format(
format_account(self.current_trainerdatas.user)
)
def libelle(self):
return u"{0}/frais {1} {2}".format(
format_account(self.expense.user, reverse=False),
self.expense.month, self.expense.year)
def title(self):
if self.is_my_account_view():
return u"Modification de mes identifiants"
else:
return u"Modification des identifiants de {0}".format(
format_account(self.current().user))
def title(self):
if self.is_my_account_view():
return u"Modification de mon mot de passe"
else:
return u"Modification du mot de passe de {0}".format(
format_account(self.current().user))
def _stream_actions(self, item):
"""
Stream actions available for the given item
:param obj item: The company instance
"""
yield Link(
self.request.route_path(
"company",
id=item.id,
),
u"Voir",
title=u"Voir l'enseigne",
icon="search",
)
if self.request.has_permission('edit.company', item):
yield Link(
self.request.route_path(
"company",
id=item.id,
),
u"Modifier",
title=u"Modifier les informations relatives à l'enseigne",
icon="pencil",
)
if self.request.has_permission("admin.company"):
if len(item.employees) > 1:
yield Link(
self.request.route_path(
"company",
id=item.id,
_query={'action': 'remove', id: self.current_user.id}
),
u"Retirer",
title=u"Retirer l'entrepreneur de cette enseigne",
icon="link",
confirm=u"{} n'aura plus accès aux données de cette "
u"l'enseigne {}. Êtes-vous sûr de vouloir continuer "
u"?".format(
format_account(self.current_user),
item.name
)
)
if item.active:
yield Link(
self.request.route_path(
"company",
id=item.id,
_query={'action': 'disable'}
),
u"Désactiver",
title=u"Désactiver cette enseigne",
icon="book",
confirm=u"L'enseigne {} ne sera plus accessible et "
u"n'apparaîtra plus dans les listes (factures, notes de "
u"dépenses ...) Êtes-vous sûr de vouloir continuer "
u"?".format(item.name)
)
else:
yield Link(
self.request.route_path(
"company",
id=item.id,
_query={'action': 'disable'}
),
u"Activer",
title=u"Ré-activer cette enseigne",
icon="book",
)
def title(self):
return u"Fiche de gestion sociale de {0}".format(
format_account(self.current_userdatas.user, False))
def check(self, payments):
"""
Check that the given expense_payments can be exported
:param obj payments: A SQLA query of ExpensePayment objects
"""
count = payments.count()
if count == 0:
title = u"Il n'y a aucun paiement à exporter"
res = {
'title': title,
'errors': [],
}
return False, res
title = u"Vous vous apprêtez à exporter {0} paiements".format(count)
res = {'title': title, 'errors': []}
for payment in payments:
expense = payment.expense
company = expense.company
if not self._check_company(company):
company_url = self.request.route_path(
"company",
id=company.id,
_query={'action': 'edit'},
)
message = ERR_COMPANY_CONFIG.format(
expense.id,
company.name,
company_url,
)
res['errors'].append(message)
continue
user = expense.user
if not self._check_user(user):
user_url = self.request.route_path(
"user",
id=user.id,
_query={'action': 'edit'},
)
message = ERR_USER_CONFIG.format(
expense.id,
strings.format_account(user),
user_url,
)
res['errors'].append(message)
continue
if not self._check_bank(payment):
payment_url = self.request.route_path(
'expensepayment', id=payment.id, _query={'action': 'edit'})
message = ERR_BANK_CONFIG.format(expense.id, payment_url)
res['errors'].append(message)
continue
if payment.waiver and not self._check_waiver(payment):
admin_url = self.request.route_path(self.admin_route_name)
message = ERR_WAIVER_CONFIG.format(admin_url)
res['errors'].append(message)
continue
return len(res['errors']) == 0, res
def title(self):
return u"Modification des identifiants de {0}".format(
format_account(self.context.user))
def check(self, payments):
"""
Check that the given expense_payments can be exported
:param obj payments: A SQLA query of ExpensePayment objects
"""
count = payments.count()
if count == 0:
title = u"Il n'y a aucun paiement à exporter"
res = {
'title': title,
'errors': [],
}
return False, res
title = u"Vous vous apprêtez à exporter {0} paiements".format(
count)
res = {'title': title, 'errors': []}
for payment in payments:
expense = payment.expense
company = expense.company
if not self._check_company(company):
company_url = self.request.route_path(
"company",
id=company.id,
_query={'action': 'edit'},
)
message = ERR_COMPANY_CONFIG.format(
expense.id,
company.name,
company_url,
)
res['errors'].append(message)
continue
user = expense.user
if not self._check_user(user):
user_url = self.request.route_path(
"user",
id=user.id,
_query={'action': 'edit'},
)
message = ERR_USER_CONFIG.format(
expense.id,
strings.format_account(user),
user_url,
)
res['errors'].append(message)
continue
if not self._check_bank(payment):
payment_url = self.request.route_path(
'expensepayment',
id=payment.id,
_query={'action': 'edit'}
)
message = ERR_BANK_CONFIG.format(
expense.id,
payment_url)
res['errors'].append(message)
continue
if payment.waiver and not self._check_waiver(payment):
admin_url = self.request.route_path(
self.admin_route_name
)
message = ERR_WAIVER_CONFIG.format(admin_url)
res['errors'].append(message)
continue
return len(res['errors']) == 0, res
