def initial_register(request):
switch_ip = request.GET.get('switch_ip', None)
switch_port = request.GET.get('switch_port', None)
client_mac = request.GET.get('client_mac', None)
u_form = InitialRegisterForm(request.POST or None, user=request.user, switch_ip=switch_ip, switch_port=switch_port, client_mac=client_mac)
if not u_form.fields:
messages.error(request, _("Incorrect URL, or already registered device."))
return redirect(reverse(
'users:profil',
kwargs={'userid': str(request.user.id)}
))
if switch_ip and switch_port:
port = Port.objects.filter(switch__interface__ipv4__ipv4=switch_ip, port=switch_port).first()
if u_form.is_valid():
messages.success(request, _("Successful registration! Please"
" disconnect and reconnect your Ethernet"
" cable to get Internet access."))
return form(
{},
'users/plugin_out.html',
request
)
return form(
{'userform': u_form, 'port': port, 'mac': client_mac},
'users/user_autocapture.html',
request
)
def note_payment(request, facture, factureid):
"""
Build a request to start the negociation with NoteKfet by using
a facture id, the price and the login/password data stored in
the preferences.
"""
user = facture.user
payment_method = find_payment_method(facture.paiement)
if not payment_method or not isinstance(payment_method, NotePayment):
messages.error(request, _("Unknown error."))
return redirect(reverse("users:profil", kwargs={"userid": user.id}))
noteform = NoteCredentialForm(request.POST or None)
if noteform.is_valid():
pseudo = noteform.cleaned_data["login"]
password = noteform.cleaned_data["password"]
result, sock, err = login(payment_method.server, payment_method.port,
pseudo, password)
if not result:
messages.error(request, err)
return form(
{
"form": noteform,
"amount": facture.prix_total()
},
"cotisations/payment.html",
request,
)
else:
result, err = don(sock, facture.prix_total(),
payment_method.id_note, facture)
if not result:
messages.error(request, err)
return form(
{
"form": noteform,
"amount": facture.prix_total()
},
"cotisations/payment.html",
request,
)
facture.valid = True
facture.save()
messages.success(request, _("The payment with note was done."))
return redirect(reverse("users:profil", kwargs={"userid": user.id}))
return form(
{
"form": noteform,
"amount": facture.prix_total()
},
"cotisations/payment.html",
request,
)
def edit_paiement(request, paiement_instance, **_kwargs):
"""
View used to edit a payment method.
"""
payment = PaiementForm(request.POST or None,
instance=paiement_instance,
prefix="payment")
payment_method = payment_method_factory(paiement_instance,
request.POST or None,
prefix='payment_method',
creation=False)
if payment.is_valid() and \
(payment_method is None or payment_method.is_valid()):
payment.save()
if payment_method is not None:
payment_method.save()
messages.success(request, _("The payment method was edited."))
return redirect(reverse('cotisations:index-paiement'))
return form(
{
'factureform': payment,
'payment_method': payment_method,
'action_name': _("Edit"),
'title': _("Edit payment method")
}, 'cotisations/facture.html', request)
def del_paiement(request, instances):
"""
View used to delete a set of payment methods.
"""
payment = DelPaiementForm(request.POST or None, instances=instances)
if payment.is_valid():
payment_dels = payment.cleaned_data['paiements']
for payment_del in payment_dels:
try:
payment_del.delete()
messages.success(
request,
_("The payment method %(method_name)s was deleted.") %
{'method_name': payment_del})
except ProtectedError:
messages.error(
request,
_("The payment method %(method_name)s can't be deleted \
because there are invoices using it.") %
{'method_name': payment_del})
return redirect(reverse('cotisations:index-paiement'))
return form(
{
'factureform': payment,
'action_name': _("Delete"),
'title': _("Delete payment method")
}, 'cotisations/facture.html', request)
def edit_options(request, section):
""" Edition des préférences générales"""
model = getattr(models, section, None)
form_instance = getattr(forms, 'Edit' + section + 'Form', None)
if not (model or form_instance):
messages.error(request, _("Unknown object."))
return redirect(reverse('preferences:display-options'))
options_instance, _created = model.objects.get_or_create()
can, msg = options_instance.can_edit(request.user)
if not can:
messages.error(
request, msg or _("You don't have the right to edit"
" this option."))
return redirect(reverse('index'))
options = form_instance(request.POST or None,
request.FILES or None,
instance=options_instance)
if options.is_valid():
with transaction.atomic(), reversion.create_revision():
options.save()
reversion.set_user(request.user)
reversion.set_comment("Field(s) edited: %s" %
', '.join(field
for field in options.changed_data))
messages.success(request, _("The preferences were edited."))
return redirect(reverse('preferences:display-options'))
return form({
'options': options,
}, 'preferences/edit_preferences.html', request)
def del_banque(request, instances):
"""
View used to delete a set of banks.
"""
bank = DelBanqueForm(request.POST or None, instances=instances)
if bank.is_valid():
bank_dels = bank.cleaned_data["banques"]
for bank_del in bank_dels:
try:
bank_del.delete()
messages.success(
request,
_("The bank %(bank_name)s was deleted.") %
{"bank_name": bank_del},
)
except ProtectedError:
messages.error(
request,
_("The bank %(bank_name)s can't be deleted because there"
" are invoices using it.") % {"bank_name": bank_del},
)
return redirect(reverse("cotisations:index-banque"))
return form(
{
"factureform": bank,
"action_name": _("Delete"),
"title": _("Delete bank"),
},
"cotisations/facture.html",
request,
)
def edit_info(request, user, userid):
""" Edite un utilisateur à partir de son id,
si l'id est différent de request.user, vérifie la
possession du droit cableur """
if user.is_class_adherent:
user_form = AdherentEditForm(
request.POST or None,
instance=user.adherent,
user=request.user
)
else:
user_form = ClubForm(
request.POST or None,
instance=user.club,
user=request.user
)
if user_form.is_valid():
if user_form.changed_data:
user_form.save()
messages.success(request, _("The user was edited."))
return redirect(reverse(
'users:profil',
kwargs={'userid': str(userid)}
))
return form(
{'userform': user_form, 'action_name': _("Edit the user")},
'users/user.html',
request
)
def del_alias(request, interface, interfaceid):
""" View used to delete an Alias object """
alias = DelAliasForm(request.POST or None, interface=interface)
if alias.is_valid():
alias_dels = alias.cleaned_data['alias']
for alias_del in alias_dels:
try:
alias_del.delete()
messages.success(
request,
_("The alias %s was deleted.") % alias_del
)
except ProtectedError:
messages.error(
request,
(_("Error: the alias %s can't be deleted.") % alias_del)
)
return redirect(reverse(
'machines:index-alias',
kwargs={'interfaceid': str(interfaceid)}
))
return form(
{'aliasform': alias, 'action_name': _("Delete")},
'machines/machine.html',
request
)
def new_club(request):
""" Vue de création d'un nouveau club,
envoie un mail pour le mot de passe"""
club = ClubForm(request.POST or None, user=request.user)
if club.is_valid():
# Virtually fill the password reset form
password_reset = PasswordResetForm(data={'email': request.user.email})
if password_reset.is_valid():
club = club.save(commit=False)
club.save()
password_reset.save(request=request, use_https=request.is_secure())
messages.success(request, _("The club %s was created,"
" an email to set the password"
" was sent.") % club.username)
return redirect(reverse(
'users:profil',
kwargs={'userid': str(club.id)}
))
else:
messages.error(request, _("The email is invalid."))
return form(
{'userform': club, 'showCGU': False, 'action_name': _("Create a club")},
'users/user.html',
request
)
def new_user(request):
""" Vue de création d'un nouvel utilisateur,
envoie un mail pour le mot de passe"""
user = AdherentCreationForm(request.POST or None, user=request.user)
GTU_sum_up = GeneralOption.get_cached_value('GTU_sum_up')
GTU = GeneralOption.get_cached_value('GTU')
if user.is_valid():
# Virtually fill the password reset form
password_reset = PasswordResetForm(data={'email': request.user.email})
if password_reset.is_valid():
user = user.save()
password_reset.save(request=request, use_https=request.is_secure())
messages.success(request, _("The user %s was created,"
" an email to set the password"
" was sent.") % user.username)
return redirect(reverse(
'users:profil',
kwargs={'userid': str(user.id)}
))
else:
messages.error(request, _("The email is invalid."))
return form(
{
'userform': user,
'GTU_sum_up': GTU_sum_up,
'GTU': GTU,
'showCGU': True,
'action_name': _("Commit")
},
'users/user.html',
request
)
def del_document_template(request, instances):
"""
View used to delete a set of document template.
"""
document_template = DelDocumentTemplateForm(request.POST or None,
instances=instances)
if document_template.is_valid():
document_template_del = document_template.cleaned_data[
'document_templates']
for document_template in document_template_del:
try:
document_template.delete()
messages.success(
request,
_("The document template %(document_template)s was deleted."
) % {'document_template': document_template})
except ProtectedError:
messages.error(
request,
_("The document template %(document_template)s can't be deleted \
because it is currently being used.") %
{'document_template': document_template})
return redirect(reverse('preferences:display-options'))
return form(
{
'preferenceform': document_template,
'action_name': _("Delete"),
'title': _("Delete document template")
}, 'preferences/preferences.html', request)
def edit_custom_invoice(request, invoice, **kwargs):
# Building the invoice form and the article formset
invoice_form = CustomInvoiceForm(request.POST or None, instance=invoice)
purchases_objects = Vente.objects.filter(facture=invoice)
purchase_form_set = modelformset_factory(Vente,
fields=("name", "number"),
extra=0,
max_num=len(purchases_objects))
purchase_form = purchase_form_set(request.POST or None,
queryset=purchases_objects)
if invoice_form.is_valid() and purchase_form.is_valid():
if invoice_form.changed_data:
invoice_form.save()
purchase_form.save()
messages.success(request, _("The invoice was edited."))
return redirect(reverse("cotisations:index-custom-invoice"))
return form(
{
"factureform": invoice_form,
"venteform": purchase_form,
"title": _("Edit custom invoice"),
},
"cotisations/edit_facture.html",
request,
)
def edit_facture(request, facture, **_kwargs):
"""
View used to edit an existing invoice.
Articles can be added or removed to the invoice and quantity
can be set as desired. This is also the view used to invalidate
an invoice.
"""
invoice_form = FactureForm(request.POST or None,
instance=facture,
user=request.user)
purchases_objects = Vente.objects.filter(facture=facture)
purchase_form_set = modelformset_factory(Vente,
fields=("name", "number"),
extra=0,
max_num=len(purchases_objects))
purchase_form = purchase_form_set(request.POST or None,
queryset=purchases_objects)
if invoice_form.is_valid() and purchase_form.is_valid():
if invoice_form.changed_data:
invoice_form.save()
purchase_form.save()
messages.success(request, _("The invoice was edited."))
return redirect(reverse("cotisations:index"))
return form(
{
"factureform": invoice_form,
"venteform": purchase_form
},
"cotisations/edit_facture.html",
request,
)
def edit_paiement(request, paiement_instance, **_kwargs):
"""
View used to edit a payment method.
"""
payment = PaiementForm(request.POST or None,
instance=paiement_instance,
prefix="payment")
payment_method = payment_method_factory(paiement_instance,
request.POST or None,
prefix="payment_method",
creation=False)
if payment.is_valid() and (payment_method is None
or payment_method.is_valid()):
payment.save()
if payment_method is not None:
payment_method.save()
messages.success(request, _("The payment method was edited."))
return redirect(reverse("cotisations:index-paiement"))
return form(
{
"factureform": payment,
"payment_method": payment_method,
"action_name": _("Edit"),
"title": _("Edit payment method"),
},
"cotisations/facture.html",
request,
)
def del_paiement(request, instances):
"""
View used to delete a set of payment methods.
"""
payment = DelPaiementForm(request.POST or None, instances=instances)
if payment.is_valid():
payment_dels = payment.cleaned_data["paiements"]
for payment_del in payment_dels:
try:
payment_del.delete()
messages.success(
request,
_("The payment method %(method_name)s was deleted.") %
{"method_name": payment_del},
)
except ProtectedError:
messages.error(
request,
_("The payment method %(method_name)s can't be deleted"
" because there are invoices using it.") %
{"method_name": payment_del},
)
return redirect(reverse("cotisations:index-paiement"))
return form(
{
"factureform": payment,
"action_name": _("Delete"),
"title": _("Delete payment method"),
},
"cotisations/facture.html",
request,
)
def mass_archive(request):
""" Permet l'archivage massif"""
pagination_number = GeneralOption.get_cached_value('pagination_number')
to_archive_form = MassArchiveForm(request.POST or None)
to_archive_list = []
if to_archive_form.is_valid():
date = to_archive_form.cleaned_data['date']
full_archive = to_archive_form.cleaned_data['full_archive']
to_archive_list = User.objects.exclude(id__in=all_has_access()).exclude(id__in=all_has_access(search_time=date)).exclude(state=User.STATE_NOT_YET_ACTIVE).exclude(state=User.STATE_FULL_ARCHIVE)
if not full_archive:
to_archive_list = to_archive_list.exclude(state=User.STATE_ARCHIVE)
if "valider" in request.POST:
if full_archive:
User.mass_full_archive(to_archive_list)
else:
User.mass_archive(to_archive_list)
messages.success(request, _("%s users were archived.") %
to_archive_list.count()
)
return redirect(reverse('users:index'))
to_archive_list = re2o_paginator(request, to_archive_list, pagination_number)
return form(
{'userform': to_archive_form, 'to_archive_list': to_archive_list},
'users/mass_archive.html',
request
)
def new_interface(request, machine, **_kwargs):
""" Ajoute une interface et son domain associé à une machine existante"""
interface_form = AddInterfaceForm(request.POST or None, user=request.user)
domain_form = DomainForm(request.POST or None)
if interface_form.is_valid():
new_interface_obj = interface_form.save(commit=False)
domain_form.instance.interface_parent = new_interface_obj
new_interface_obj.machine = machine
if domain_form.is_valid():
new_domain_obj = domain_form.save(commit=False)
new_interface_obj.save()
new_domain_obj.interface_parent = new_interface_obj
new_domain_obj.save()
messages.success(request, _("The interface was created."))
return redirect(reverse(
'users:profil',
kwargs={'userid': str(machine.user.id)}
))
i_mbf_param = generate_ipv4_mbf_param(interface_form, False)
return form(
{
'interfaceform': interface_form,
'domainform': domain_form,
'i_mbf_param': i_mbf_param,
'action_name': _("Create an interface")
},
'machines/machine.html',
request
)
def del_service(request, service_instance, **_kwargs):
"""Suppression d'un service de la page d'accueil"""
if request.method == "POST":
service_instance.delete()
messages.success(request, _("The service was deleted."))
return redirect(reverse('preferences:display-options'))
return form({
'objet': service_instance,
'objet_name': 'service'
}, 'preferences/delete.html', request)
def del_reminder(request, reminder_instance, **_kwargs):
"""Destruction d'un reminder"""
if request.method == "POST":
reminder_instance.delete()
messages.success(request, _("The reminder was deleted."))
return redirect(reverse('preferences:display-options'))
return form({
'objet': reminder_instance,
'objet_name': 'reminder'
}, 'preferences/delete.html', request)
def del_serviceuser(request, serviceuser, **_kwargs):
"""Suppression d'un ou plusieurs serviceusers"""
if request.method == "POST":
serviceuser.delete()
messages.success(request, _("The service user was deleted."))
return redirect(reverse('users:index-serviceusers'))
return form(
{'objet': serviceuser, 'objet_name': 'service user'},
'users/delete.html',
request
)
def add_service(request):
"""Ajout d'un service de la page d'accueil"""
service = ServiceForm(request.POST or None, request.FILES or None)
if service.is_valid():
service.save()
messages.success(request, _("The service was added."))
return redirect(reverse('preferences:display-options'))
return form({
'preferenceform': service,
'action_name': _("Add a service")
}, 'preferences/preferences.html', request)
def add_radiuskey(request):
"""Ajout d'une clef radius"""
radiuskey = RadiusKeyForm(request.POST or None)
if radiuskey.is_valid():
radiuskey.save()
messages.success(request, _("The RADIUS key was added."))
return redirect(reverse('preferences:display-options'))
return form(
{
'preferenceform': radiuskey,
'action_name': _("Add a RADIUS key")
}, 'preferences/preferences.html', request)
def add_reminder(request):
"""Ajout d'un mail de rappel"""
reminder = ReminderForm(request.POST or None, request.FILES or None)
if reminder.is_valid():
reminder.save()
messages.success(request, _("The reminder was added."))
return redirect(reverse('preferences:display-options'))
return form(
{
'preferenceform': reminder,
'action_name': _("Add a reminder")
}, 'preferences/preferences.html', request)
def add_mailcontact(request):
"""Add a contact email adress."""
mailcontact = MailContactForm(request.POST or None, request.FILES or None)
if mailcontact.is_valid():
mailcontact.save()
messages.success(request, _("The contact email address was created."))
return redirect(reverse('preferences:display-options'))
return form(
{
'preferenceform': mailcontact,
'action_name': _("Add a contact email address")
}, 'preferences/preferences.html', request)
def edit_radiuskey(request, radiuskey_instance, **_kwargs):
"""Edition des clefs radius"""
radiuskey = RadiusKeyForm(request.POST or None,
instance=radiuskey_instance)
if radiuskey.is_valid():
radiuskey.save()
messages.success(request, _("The RADIUS key was edited."))
return redirect(reverse('preferences:display-options'))
return form({
'preferenceform': radiuskey,
'action_name': _("Edit")
}, 'preferences/preferences.html', request)
def del_cost_estimate(request, estimate, **_kwargs):
"""
View used to delete an existing invocie.
"""
if request.method == "POST":
estimate.delete()
messages.success(request, _("The cost estimate was deleted."))
return redirect(reverse('cotisations:index-cost-estimate'))
return form({
'objet': estimate,
'objet_name': _("Cost estimate")
}, 'cotisations/delete.html', request)
def del_custom_invoice(request, invoice, **_kwargs):
"""
View used to delete an existing invocie.
"""
if request.method == "POST":
invoice.delete()
messages.success(request, _("The invoice was deleted."))
return redirect(reverse('cotisations:index-custom-invoice'))
return form({
'objet': invoice,
'objet_name': _("Invoice")
}, 'cotisations/delete.html', request)
def credit_solde(request, user, **_kwargs):
"""
View used to edit the balance of a user.
Can be use either to increase or decrease a user's balance.
"""
try:
balance = find_payment_method(Paiement.objects.get(is_balance=True))
except Paiement.DoesNotExist:
credit_allowed = False
else:
credit_allowed = balance is not None and balance.can_credit_balance(
request.user)
if not credit_allowed:
messages.error(request,
_("You are not allowed to credit your balance."))
return redirect(reverse("users:profil", kwargs={"userid": user.id}))
refill_form = RechargeForm(request.POST or None,
user=user,
user_source=request.user)
if refill_form.is_valid():
price = refill_form.cleaned_data["value"]
invoice = Facture(user=user)
invoice.paiement = refill_form.cleaned_data["payment"]
p = find_payment_method(invoice.paiement)
if hasattr(p, "check_price"):
price_ok, msg = p.check_price(price, user)
refill_form.add_error(None, msg)
else:
price_ok = True
if price_ok:
invoice.save(request=request)
Vente.objects.create(
facture=invoice,
name="solde",
prix=refill_form.cleaned_data["value"],
number=1,
)
return invoice.paiement.end_payment(invoice, request)
p = get_object_or_404(Paiement, is_balance=True)
return form(
{
"factureform": refill_form,
"balance": user.solde,
"title": _("Refill your balance"),
"action_name": _("Pay"),
"max_balance": find_payment_method(p).maximum_balance,
},
"cotisations/facture.html",
request,
)
def edit_mailcontact(request, mailcontact_instance, **_kwargs):
"""Edit contact email adress."""
mailcontact = MailContactForm(request.POST or None,
request.FILES or None,
instance=mailcontact_instance)
if mailcontact.is_valid():
mailcontact.save()
messages.success(request, _("The contact email address was edited."))
return redirect(reverse('preferences:display-options'))
return form({
'preferenceform': mailcontact,
'action_name': _("Edit")
}, 'preferences/preferences.html', request)
def add_listright(request):
""" Ajouter un droit/groupe, nécessite droit bureau.
Obligation de fournir un gid pour la synchro ldap, unique """
listright = NewListRightForm(request.POST or None)
if listright.is_valid():
listright.save()
messages.success(request, _("The group of rights was added."))
return redirect(reverse('users:index-listright'))
return form(
{'userform': listright, 'action_name': _("Add a group of rights")},
'users/user.html',
request
)
