def userdatas_delete(userdatas, request):
"""
delete a user account and its userdatas
"""
if userdatas.user is not None:
logger.debug(u"Suppression des données et du compte de : {0}".format(
format_account(userdatas)))
# Suppression du compte utilisateur (la cascade va entrainer la
# suppression des données associées)
user_delete(userdatas.user, request)
message = u"Les données de '{0}' ont bien été effacées".format(
format_account(userdatas))
request.session.flash(message)
else:
try:
logger.debug(u"Suppression des données de : {0}".format(
format_account(userdatas)))
request.dbsession.delete(userdatas)
request.dbsession.flush()
message = u"Les données de '{0}' ont bien été effacées".format(
format_account(userdatas))
request.session.flash(message)
except:
logger.exception(u"Erreur à la suppression des données")
err_msg = u"Erreur à la suppression des données de '{0}'".format(
format_account(userdatas))
request.session.flash(err_msg, 'error')
return HTTPFound(request.route_path('userdatas'))
def user_delete(account, request):
"""
disable a user and its enteprises
"""
try:
# First we disable associated companies if we're going to delete the
# only employee
for company in account.companies:
if len(company.employees) == 1:
company.disable()
message = u"L'entreprise {0} a été désactivée".format(
company.name
)
request.dbsession.merge(company)
logger.debug(u"Deleting account : {0}".format(format_account(account)))
request.dbsession.delete(account)
request.dbsession.flush()
message = u"Le compte '{0}' a bien été supprimé".format(
format_account(account))
request.session.flash(message)
except:
logger.exception(u"Erreur à la suppression du compte")
err_msg = u"Erreur à la suppression du compte de '{0}'".format(
format_account(account)
)
request.session.flash(err_msg, 'error')
return HTTPFound(request.route_path("users"))
def user_delete(account, request):
"""
disable a user and its enteprises
"""
try:
# First we disable associated companies if we're going to delete the
# only employee
for company in account.companies:
if len(company.employees) == 1:
company.disable()
message = u"L'entreprise {0} a été désactivée".format(
company.name)
request.dbsession.merge(company)
logger.debug(u"Deleting account : {0}".format(format_account(account)))
request.dbsession.delete(account)
request.dbsession.flush()
message = u"Le compte '{0}' a bien été supprimé".format(
format_account(account))
request.session.flash(message)
except:
logger.exception(u"Erreur à la suppression du compte")
err_msg = u"Erreur à la suppression du compte de '{0}'".format(
format_account(account))
request.session.flash(err_msg, 'error')
return HTTPFound(request.route_path("users"))
def submit_success(self, appstruct):
"""
Add a user to the database
Add its companies
Add a relationship between companies and the new account
"""
if "companies" in appstruct:
company_names = set(appstruct.pop('companies'))
else:
company_names = None
groups = set(appstruct.pop('groups', []))
password = appstruct.pop('pwd', None)
if self.context.__name__ == 'user':
user_model = self.schema.objectify(appstruct, self.context)
logger.info(u"Edit user : {0}".format(format_account(user_model)))
else:
user_model = self.schema.objectify(appstruct)
logger.info(u"Add user : {0}".format(format_account(user_model)))
if password is not None:
user_model.set_password(password)
user_model.groups = groups
self._handle_companies(company_names, user_model)
user_model = self.dbsession.merge(user_model)
# Here we flush to get an id for the redirect
self.dbsession.flush()
self.session.flash(self.validate_msg)
return HTTPFound(self.redirect_url(user_model))
def userdatas_delete(userdatas, request):
"""
delete a user account and its userdatas
"""
if userdatas.user is not None:
logger.debug(u"Suppression des données et du compte de : {0}".format(
format_account(userdatas)
))
# Suppression du compte utilisateur (la cascade va entrainer la
# suppression des données associées)
user_delete(userdatas.user, request)
message = u"Les données de '{0}' ont bien été effacées".format(
format_account(userdatas)
)
request.session.flash(message)
else:
try:
logger.debug(u"Suppression des données de : {0}".format(
format_account(userdatas)
))
request.dbsession.delete(userdatas)
request.dbsession.flush()
message = u"Les données de '{0}' ont bien été effacées".format(
format_account(userdatas)
)
request.session.flash(message)
except:
logger.exception(u"Erreur à la suppression des données")
err_msg = u"Erreur à la suppression des données de '{0}'".format(
format_account(userdatas)
)
request.session.flash(err_msg, 'error')
return HTTPFound(request.route_path('userdatas'))
def user_enable(request):
"""
enable a user and its enterprise (if he has only one)
"""
account = request.context
if not account.enabled():
try:
account.enable()
request.dbsession.merge(account)
logger.info(u"The user {0} has been enabled".format(
format_account(account)))
message = u"L'utilisateur {0} a été (ré)activé.".format(
format_account(account))
request.session.flash(message)
if len(account.companies) == 1:
company = account.companies[0]
company_enable(request, company=company)
except:
logger.exception(u"Erreur à l'activation du compte")
err_msg = u"Erreur à l'activation du compte de '{0}'".format(
format_account(account))
request.session.flash(err_msg, 'error')
url = request.referer
if url is None:
url = request.route_path("users")
return HTTPFound(url)
def user_enable(request):
"""
enable a user and its enterprise (if he has only one)
"""
account = request.context
if not account.enabled():
try:
account.enable()
request.dbsession.merge(account)
logger.info(u"The user {0} has been enabled".format(
format_account(account))
)
message = u"L'utilisateur {0} a été (ré)activé.".format(
format_account(account)
)
request.session.flash(message)
if len(account.companies) == 1:
company = account.companies[0]
company_enable(request, company=company)
except:
logger.exception(u"Erreur à l'activation du compte")
err_msg = u"Erreur à l'activation du compte de '{0}'".format(
format_account(account)
)
request.session.flash(err_msg, 'error')
url = request.referer
if url is None:
url = request.route_path("users")
return HTTPFound(url)
def submit_success(self, appstruct):
"""
Add a user to the database
Add its companies
Add a relationship between companies and the new account
"""
if "companies" in appstruct:
company_names = set(appstruct.pop('companies'))
else:
company_names = None
groups = set(appstruct.pop('groups', []))
password = appstruct.pop('pwd', None)
if self.context.__name__ == 'user':
user_model = self.schema.objectify(appstruct, self.context)
logger.info(u"Edit user : {0}" .format(format_account(user_model)))
else:
user_model = self.schema.objectify(appstruct)
logger.info(u"Add user : {0}" .format(format_account(user_model)))
if password is not None:
user_model.set_password(password)
user_model.groups = groups
self._handle_companies(company_names, user_model)
user_model = self.dbsession.merge(user_model)
# Here we flush to get an id for the redirect
self.dbsession.flush()
self.session.flash(self.validate_msg)
return HTTPFound(self.redirect_url(user_model))
def _build_return_value(self, schema, appstruct, query):
writer = self._init_writer()
participants, conseillers = self._format_datas_for_export(query)
for name, activities in participants.items():
writer.add_row({
'name': name,
'date': '',
'title': '',
'duration': '',
'conseillers': ''
})
for activity in activities:
writer.add_row({
'name':
'',
'date':
activity.datetime,
'title':
self._activity_title(activity),
'duration':
activity.duration,
'conseillers':
','.join([
render_api.format_account(conseiller)
for conseiller in activity.conseillers
])
})
sheet_writer = self._init_next_sheet(writer)
for name, activities in conseillers.items():
sheet_writer.add_row({
'name': name,
'date': '',
'title': '',
'duration': '',
'participants': ''
})
for activity in activities:
sheet_writer.add_row({
'name':
'',
'date':
activity.datetime,
'title':
self._activity_title(activity),
'duration':
activity.duration,
'participants':
','.join([
render_api.format_account(user)
for user in activity.participants
])
})
if hasattr(sheet_writer, '_populate'):
sheet_writer._populate()
write_file_to_request(self.request, self.filename, writer.render())
return self.request.response
def _disable_user(self, user):
"""
disable the current user
"""
if user.enabled():
user.disable()
self.dbsession.merge(user)
log.info(u"The user {0} has been disabled".format(
format_account(user)))
message = u"L'utilisateur {0} a été désactivé.".format(
format_account(user))
self.session.flash(message)
def _disable_user(self, user):
"""
disable the current user
"""
if user.enabled():
user.disable()
self.dbsession.merge(user)
logger.info(u"The user {0} has been disabled".format(
format_account(user)))
message = u"L'utilisateur {0} a été désactivé.".format(
format_account(user))
self.session.flash(message)
def _format_datas_for_export(self, query):
"""
Returns datas in order to be able to easily use them in a for loop
"""
participants = {}
conseillers = {}
for activity in query:
for participant in activity.participants:
participants.setdefault(render_api.format_account(participant),
[]).append(activity)
for conseiller in activity.conseillers:
conseillers.setdefault(render_api.format_account(conseiller),
[]).append(activity)
return participants, conseillers
def _build_return_value(self, schema, appstruct, query):
writer = self._init_writer()
participants, conseillers = self._format_datas_for_export(query)
for name, activities in participants.items():
writer.add_row({
'name': name,
'date': '',
'title': '',
'duration': '',
'conseillers': ''
})
for activity in activities:
writer.add_row({
'name': '',
'date': activity.datetime,
'title': self._activity_title(activity),
'duration': activity.duration,
'conseillers': ','.join([
render_api.format_account(conseiller)
for conseiller in activity.conseillers])
})
sheet_writer = self._init_next_sheet(writer)
for name, activities in conseillers.items():
print("Adding a row")
sheet_writer.add_row({
'name': name,
'date': '',
'title': '',
'duration': '',
'participants': ''
})
for activity in activities:
print(u"Adding a row")
sheet_writer.add_row({
'name': '',
'date': activity.datetime,
'title': self._activity_title(activity),
'duration': activity.duration,
'participants': ','.join([
render_api.format_account(user)
for user in activity.participants])
})
if hasattr(sheet_writer, '_populate'):
sheet_writer._populate()
write_file_to_request(self.request, self.filename, writer.render())
return self.request.response
def user_view(request):
"""
Return user view only datas
"""
title = u"{0}".format(format_account(request.context))
populate_actionmenu(request, request.context)
return dict(title=title, user=request.context)
def _format_datas_for_export(self, query):
"""
Returns datas in order to be able to easily use them in a for loop
"""
participants = {}
conseillers = {}
for activity in query:
for participant in activity.participants:
participants.setdefault(
render_api.format_account(participant), []
).append(activity)
for conseiller in activity.conseillers:
conseillers.setdefault(
render_api.format_account(conseiller), []
).append(activity)
return participants, conseillers
def stream_workshop_entries_for_export(query):
"""
Stream workshop datas for csv export
"""
for workshop in query.all():
hours = sum(t.duration[0] for t in workshop.timeslots)
minutes = sum(t.duration[1] for t in workshop.timeslots)
duration = hours * 60 + minutes
for participant in workshop.participants:
attended = False
for timeslot in workshop.timeslots:
# On exporte une ligne que si le user était là au moins une
# fois
if timeslot.user_status(participant.id) == u'Présent':
attended = True
break
if attended:
yield {
"date": workshop.timeslots[0].start_time.date(),
"label": workshop.name,
"participant": format_account(participant),
"leaders": '\n'.join(workshop.leaders),
"duration": duration,
}
def stream_workshop_entries_for_export(query):
for workshop in query.all():
hours = sum(t.duration[0] for t in workshop.timeslots)
minutes = sum(t.duration[1] for t in workshop.timeslots)
duration = hours * 60 + minutes
for participant in workshop.participants:
attended = False
for timeslot in workshop.timeslots:
# On exporte une ligne que si le user était là au moins une
# fois
if timeslot.user_status(participant.id) == u'Présent':
attended = True
break
if attended:
yield {
"label": workshop.name,
"participant": format_account(participant),
"leaders": '\n'.join(workshop.leaders),
"duration": duration,
}
def title(self):
"""
form title
"""
return u"Modification de {0}".format(
format_account(self.context)
)
def check(self, expenses):
"""
Check if we can export the expenses
:param expenses: the expenses to export
"""
count = expenses.count()
if count == 0:
title = u"Il n'y a aucune note de frais à exporter"
res = {'title': title, 'errors': [""]}
return res
title = u"Vous vous apprêtez à exporter {0} notes de frais".format(
count)
errors = []
if not self.check_config(self.request.config):
url1 = self.request.route_path('admin_expense')
url2 = self.request.route_path('admin_cae')
errors.append(EXPENSE_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 frais de {0} n'est pas exportable\
<br />{1}".format(format_account(expense.user), error))
res = {'title': title, 'errors': errors}
return res
def title(self):
return u"Notes de dépense de {0} pour la période de {1} {2}"\
.format(
format_account(self.request.context.user),
month_name(self.context.month),
self.context.year,
)
def check(self, expenses) :
"""
Check if we can export the expenses
:param expenses: the expenses to export
"""
count = expenses.count()
if count == 0:
title = u"Il n'y a aucune note de frais à exporter"
res = {'title': title,
'errors': [""]}
return res
title = u"Vous vous apprêtez à exporter {0} notes de frais".format(
count)
errors = []
if not self.check_config(self.request.config):
url1 = self.request.route_path('admin_expense')
url2 = self.request.route_path('admin_cae')
errors.append(EXPENSE_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 frais de {0} n'est pas exportable\
<br />{1}".format(format_account(expense.user), error))
res = {'title': title, 'errors':errors}
return res
def title(self):
"""
Return the title of the page
"""
return u"Notes de dépense de {0} pour la période de {1} {2}".format(
format_account(self.request.context.user), month_name(self.month), self.year
)
def title(self):
"""
title of the form
"""
return u"Désactivation du compte {0}".format(
format_account(self.context)
)
def title(self):
"""
Dynamic page title
"""
participants = self.request.context.participants
participants_list = [render_api.format_account(account)
for account in participants]
return u"Accompagnement de {0}".format(", ".join(participants_list))
def title(self):
"""
Dynamic page title
"""
participants = self.request.context.participants
participants_list = [render_api.format_account(account)
for account in participants]
return u"Accompagnement de {0}".format(", ".join(participants_list))
def user_view(request):
"""
Return user view only datas
"""
title = u"{0}".format(format_account(request.context))
populate_actionmenu(request, request.context)
return dict(title=title,
user=request.context)
def user_delete(request):
"""
disable a user and its enteprises
"""
account = request.context
try:
log.debug(u"Deleting account : {0}".format(format_account(account)))
request.dbsession.delete(account)
request.dbsession.flush()
message = u"Le compte '{0}' a bien été supprimé".format(
format_account(account))
request.session.flash(message)
except:
log.exception(u"Erreur à la suppression du compte")
err_msg = u"Erreur à la suppression du compte de '{0}'".format(
format_account(account))
request.session.flash(err_msg, 'error')
return HTTPFound(request.route_path("users"))
def subject(self):
"""
return the subject of the email
"""
subject = u"Notes de frais de {0} : {1}".format(
format_account(self.expense.user),
format_expense_status(self.expense),
)
return subject
def subject(self):
"""
return the subject of the email
"""
subject = u"Notes de dépense de {0} : {1}".format(
format_account(self.expense.user),
format_expense_status(self.expense),
)
return subject
def submit_success(self, appstruct):
if self.context.__name__ == 'userdatas':
model = self.schema.objectify(appstruct, self.context)
else:
from autonomie.views import render_api
confirmation = self.request.GET.get('confirmation', '0')
lastname = appstruct['coordonnees_lastname']
email = appstruct['coordonnees_email1']
if lastname and confirmation == '0':
query = UserDatas.query().filter(
or_(
UserDatas.coordonnees_lastname == lastname,
UserDatas.coordonnees_email1 == email,
))
query_count = query.count()
if query_count > 0:
if query_count == 1:
msg = u"Une entrée de gestion sociale similaire \
a déjà été créée: <ul>"
else:
msg = u"{0} entrées de gestion sociale similaires ont \
déjà été créées : <ul>".format(query_count)
for entry in query:
msg += u"<li><a href='%s'>%s (%s)</a></li>" % (
self.request.route_path('userdata', id=entry.id),
render_api.format_account(entry),
entry.coordonnees_email1,
)
msg += u"</ul>"
form = self._get_form()
form.action = self.request.current_route_path(
_query={
'action': 'new',
'confirmation': '1'
})
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
model = self.schema.objectify(appstruct)
model = self.dbsession.merge(model)
self.dbsession.flush()
self.post_integration(model)
self.session.flash(self.validation_msg)
return HTTPFound(self.request.route_path('userdata', id=model.id))
def submit_success(self, appstruct):
if self.context.__name__ == 'userdatas':
model = self.schema.objectify(appstruct, self.context)
else:
from autonomie.views import render_api
confirmation = self.request.GET.get('confirmation', '0')
lastname = appstruct['coordonnees_lastname']
email = appstruct['coordonnees_email1']
if lastname and confirmation == '0':
query = UserDatas.query().filter(
or_(
UserDatas.coordonnees_lastname == lastname,
UserDatas.coordonnees_email1 == email,
)
)
query_count = query.count()
if query_count > 0:
if query_count == 1:
msg = u"Une entrée de gestion sociale similaire \
a déjà été créée: <ul>"
else:
msg = u"{0} entrées de gestion sociale similaires ont \
déjà été créées : <ul>".format(query_count)
for entry in query:
msg += u"<li><a href='%s'>%s (%s)</a></li>" % (
self.request.route_path('userdata', id=entry.id),
render_api.format_account(entry),
entry.coordonnees_email1,
)
msg += u"</ul>"
form = self._get_form()
form.action = self.request.current_route_path(
_query={'action': 'new', 'confirmation': '1'}
)
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
model = self.schema.objectify(appstruct)
model = self.dbsession.merge(model)
self.dbsession.flush()
self.post_integration(model)
self.session.flash(self.validation_msg)
return HTTPFound(self.request.route_path('userdata', id=model.id))
def body(self):
"""
return the body of the email
"""
status_verb = get_status_verb(self.new_status)
# If the document is validated, we directly send the link to the pdf
# file
if self.new_status == 'valid':
query_args = dict(view="pdf")
else:
query_args = {}
addr = self.request.route_url(
self.document.type_,
id=self.document.id,
_query=query_args,
)
addr = format_link(self.settings, addr)
docnumber = self.document.internal_number.lower()
customer = self.document.customer.name.capitalize()
project = self.document.project.name.capitalize()
if self.document.is_invoice():
docname = u"La facture"
gender = u"e"
determinant = u"la"
elif self.document.is_cancelinvoice():
docname = u"L'avoir"
gender = u""
determinant = u"le"
else:
docname = u"Le devis"
gender = u""
determinant = u"le"
if self.document.statusComment:
comment = self.document.statusComment
else:
comment = u"Aucun"
username = render_api.format_account(self.document.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 body(self):
"""
return the body of the email
"""
status_verb = get_status_verb(self.new_status)
# If the document is validated, we directly send the link to the pdf
# file
if self.new_status == 'valid':
query_args = dict(view="pdf")
else:
query_args = {}
addr = self.request.route_url(
self.document.type_,
id=self.document.id,
_query=query_args,
)
addr = format_link(self.settings, addr)
docnumber = self.document.number.lower()
customer = self.document.customer.name.capitalize()
project = self.document.project.name.capitalize()
if self.document.is_invoice():
docname = u"La facture"
gender = u"e"
determinant = u"la"
elif self.document.is_cancelinvoice():
docname = u"L'avoir"
gender = u""
determinant = u"le"
else:
docname = u"Le devis"
gender = u""
determinant = u"le"
if self.document.statusComment:
comment = self.document.statusComment
else:
comment = u"Aucun"
username = render_api.format_account(self.document.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 add_company(self, name, user):
"""
Add a company 'name' in the database
( set its goal by default )
"""
log.info(u"Adding company : %s" % name)
company = Company()
company.name = name
company.goal = u"Entreprise de {0}".format(format_account(user))
company.contribution = self.request.config.get('contribution_cae')
company = self.dbsession.merge(company)
self.dbsession.flush()
return company
def _add_company(self, name, user):
"""
Add a company 'name' in the database
( set its goal by default )
"""
logger.info(u"Adding company : %s" % name)
company = Company()
company.name = name
company.goal = u"Entreprise de {0}".format(
format_account(user, reverse=False))
company.contribution = self.request.config.get('contribution_cae')
company = self.dbsession.merge(company)
self.dbsession.flush()
return company
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'))
"""
if roles and not hasattr(roles, "__iter__"):
roles = [roles]
if roles:
query = get_user_by_roles(roles)
else:
query = User.query()
return [(unicode(u.id), render_api.format_account(u)) for u in query]
def submit_success(self, appstruct):
"""
Edit the database entry for the current user
"""
user = self.get_user(self.request.context, appstruct)
if 'companies' in appstruct:
companies = set(appstruct.get('companies'))
user.companies = []
for company_name in companies:
company = self.get_company(company_name, user)
user.companies.append(company)
log.info(u"Edit user : {0}" .format(format_account(user)))
user = self.dbsession.merge(user)
self.dbsession.flush()
self.session.flash(self.validate_msg)
return HTTPFound(self.request.route_path("user", id=user.id))
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("expensesheet", 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 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("expensesheet", 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 _get_appstruct_from_activity(activity):
"""
Return an activity as a form appstruct
"""
appstruct = activity.appstruct()
participants = activity.participants
conseillers = activity.conseillers
appstruct['participants'] = [p.id for p in participants]
appstruct['conseillers'] = [c.id for c in conseillers]
appstruct['attendances'] = [
{
'event_id': att.event_id,
'account_id': att.account_id,
'username': render_api.format_account(att.user),
'status': att.status,
} for att in activity.attendances]
return appstruct
def submit_success(self, appstruct):
"""
Add a user to the database
Add its companies
Add a relationship between companies and the new account
"""
user = self.get_user(User(), appstruct)
if 'companies' in appstruct:
companies = set(appstruct.get('companies'))
user.companies = []
for company_name in companies:
company = self.get_company(company_name, user)
user.companies.append(company)
log.info(u"Add user : {0}" .format(format_account(user)))
user = self.dbsession.merge(user)
self.dbsession.flush()
self.session.flash(self.validate_msg)
return HTTPFound(self.request.route_path("user", id=user.id))
def _get_appstruct_from_activity(activity):
"""
Return an activity as a form appstruct
"""
appstruct = activity.appstruct()
participants = activity.participants
conseillers = activity.conseillers
companies = activity.companies
appstruct['participants'] = [p.id for p in participants]
appstruct['conseillers'] = [c.id for c in conseillers]
appstruct['companies'] = [c.id for c in companies]
appstruct['attendances'] = [{
'event_id': att.event_id,
'account_id': att.account_id,
'username': render_api.format_account(att.user),
'status': att.status,
} for att in activity.attendances]
return appstruct
def company_remove_employee_view(context, request):
"""
Enlève un employé de l'entreprise courante
"""
uid = request.params.get("uid")
if not uid:
request.session.flash("Missing uid parameter", "error")
user = User.get(uid)
if not user:
request.session.flash("User not found", "error")
if user in context.employees:
context.employees = [employee for employee in context.employees if employee != user]
request.session.flash(
u"L'utilisateur {0} ne fait plus partie de l'entreprise {1}".format(format_account(user), context.name)
)
url = request.referer
if url is None:
url = request.route_path("company", id=context.id)
return HTTPFound(url)
def company_remove_employee_view(context, request):
"""
Enlève un employé de l'entreprise courante
"""
uid = request.params.get('uid')
if not uid:
request.session.flash('Missing uid parameter', 'error')
user = User.get(uid)
if not user:
request.session.flash('User not found', 'error')
if user in context.employees:
context.employees = [
employee for employee in context.employees if employee != user
]
request.session.flash(
u"L'utilisateur {0} ne fait plus partie de l'entreprise {1}".
format(format_account(user), context.name))
url = request.referer
if url is None:
url = request.route_path('company', id=context.id)
return HTTPFound(url)
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"Une entrée de gestion sociale similaire \
a déjà été créée: <ul>"
else:
msg = u"{0} entrées de gestion sociale similaires ont \
déjà été créées : <ul>".format(query_count)
for entry in query:
msg += u"<li><a href='%s'>%s (%s)</a></li>" % (
self.request.route_path('userdata', id=entry.id),
format_account(entry),
entry.coordonnees_email1,
)
msg += u"</ul>"
form = self._get_form()
form.action = self.request.current_route_path(_query={
'action': 'new',
'confirmation': '1'
})
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 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 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,
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('admin_expense_treasury')
message = ERR_WAIVER_CONFIG.format(admin_url)
res['errors'].append(message)
continue
return res
def libelle(self):
return u"{0}/frais {1} {2}".format(
render_api.format_account(self.expense.user, reverse=False),
self.expense.month,
self.expense.year
)
def title(self):
"""
title of the form
"""
return u"Désactivation du compte {0}".format(
format_account(self.context))
def libelle(self):
return u"{0}/frais {1} {2}".format(
render_api.format_account(self.expense.user, reverse=False),
self.expense.month, self.expense.year)
def title(self):
"""
form title
"""
return u"Modification de {0}".format(format_account(self.context))
def title(self):
return u"Gestion sociale : {0}".format(
format_account(self.request.context))
def title(self):
return u"Gestion sociale : {0}".format(
format_account(self.request.context)
)
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 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,
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(
'admin_expense_treasury'
)
message = ERR_WAIVER_CONFIG.format(admin_url)
res['errors'].append(message)
continue
return res
def title(self):
"""
form title
"""
return u"Édition de {0}".format(
format_account(self.request.context))