views.py

# epl_version ="v2.00 (Chimnechilde)"
# date_version ="July 9, 2021"
# Mise au niveau de :
epl_version ="v2.01.6-beta (~Bathilde)"
date_version ="October 7, 2021"
#branche = multi

from django.shortcuts import render

from .models import *

from .forms import *

from django.core.mail import send_mail

from django.db.models.functions import Now

from django.contrib.auth.decorators import login_required

from django.utils.translation import ugettext as _

from django.contrib.auth.models import User

from django.contrib.auth import logout

from django.http import HttpResponseRedirect, HttpResponse
import os

from django.contrib import messages

lastrked =None
webmaster =""
try:
    webmaster = ReplyMail.objects.all().order_by('pk')[1].sendermail
    zz =1
except:
    pass

try:
    replymail =ReplyMail.objects.all().order_by('pk')[0].sendermail
except:
    replymail =BddAdmin.objects.all().order_by('pk')[0].contact


def serial_title(e):
    """sorting by title"""
    return e.title
def serial_id(e):
    """sorting by sid"""
    return e.sid
def coll_cn(e):
    """sorting by cn, title"""
    return (e.cn, e.title)


def selectbdd(request):

    k =logstatus(request)
    version =epl_version

    BDD_CHOICES =('',_('Sélectionnez votre projet')),

    for i in [n for n in range(100)]:
        if os.path.isfile('{:02d}.db'.format(i)):
            p = Project.objects.using('{:02d}'.format(i)).all().order_by('pk')[0].name
            BDD_CHOICES += ('{:02d}'.format(i), '{:02d}'.format(i) + " - " + p),

    if len(BDD_CHOICES) ==2:
        return HttpResponseRedirect(BDD_CHOICES[1][0])
        # return home(request, BDD_CHOICES[1][0])
    else:
        class BddSel_Form(forms.Form):
            bddname = forms.ChoiceField(required = True, widget=forms.Select, choices=BDD_CHOICES)

        f = BddSel_Form(request.POST or None)

        if f.is_valid():
            bdd = f.cleaned_data['bddname']
            return HttpResponseRedirect(bdd)
            # return home(request, bdd)

    #abstract :
    librnbr =0
    itemrecnbr =0
    instrnbr =0
    usernbr =len(User.objects.all())
    projnbr =len(BDD_CHOICES) -1
    totcand =0
    for bdd in BDD_CHOICES[1:]:
        librnbr +=len(Library.objects.using(bdd[0]).all())
        itemrecnbr +=len(ItemRecord.objects.using(bdd[0]).all())
        instrnbr +=len(Instruction.objects.using(bdd[0]).all())
        cand =[]
        for e in ItemRecord.objects.using(bdd[0]).all():
            if len(ItemRecord.objects.using(bdd[0]).filter(sid =e.sid)) >1 and not e.sid in cand:
                cand.append(e.sid)
        totcand +=len(cand)

    librnbr =librnbr - projnbr #checkers are not libraries ! (one checker per project)

    return render(request, 'epl/selectbdd.html', locals())


def logstatus(request):
    if request.user.is_authenticated:
        k = request.user.get_username()
    else:
        k =0
    return k


def home(request, bdd):

    "Homepage"

    k =logstatus(request)
    version =epl_version

    #Vérification que tous les utilisateurs sont bien enregistrés
    email_list =[]
    for lib in Library.objects.using(bdd).all():
        if lib.contact and lib.contact not in email_list:
            email_list.append(lib.contact)
        if lib.contact_bis and lib.contact_bis not in email_list:
            email_list.append(lib.contact_bis)
        if lib.contact_ter and lib.contact_ter not in email_list:
            email_list.append(lib.contact_ter)
    for adm in BddAdmin.objects.using(bdd).all():
        if adm.contact not in email_list:
            email_list.append(adm.contact)
    utermail_list =[]
    for uter in Utilisateur.objects.using(bdd).all():
        utermail_list.append(uter.mail)

    diffa =set(email_list) - set(utermail_list)
    diffb =set(utermail_list) - set(email_list)
    if diffa !=set():
        messages.info(request, _("Anomalie détectée. Pas d'utilisateur associé aux mails suivants : ") + str(diffa) + ". " + "Veuillez alerter l'administrateur")

    if diffb != set():
        messages.info(request, _("Anomalie détectée. Les utilisateurs dont les mails suivent sont inutilisés : ") + str(diffb) + ". " + "Veuillez alerter l'administrateur")

    #La partie de code ci-dessous est reproduite dans la vue adminbase(request, bdd) = Synchronisation de la base locale (utilisateurs) avec la base générale (users)
    for e in Utilisateur.objects.using(bdd).all():#1/2 création d'éventuels nouveaux users dans la base générale
        try:
            user =User.objects.get(username =e.username)
        except:
            user =User.objects.create_user(username =e.username, email =e.mail, password ="glass onion")

    #2/2 (see upper, this order is important)
    suffixe = "@" + str(bdd)
    for j in User.objects.all(): #Suppression d'users pour lesquels l'utilisateur a été supprimé de la base locale
        if j.username[-3:] ==suffixe:
            try:
                utilisateur =Utilisateur.objects.using(bdd).get(username =j.username)
            except:
                j.delete() #suppression dans la bdd générale

    project = Project.objects.using(bdd).all().order_by('pk')[0].name

    LIBRARY_CHOICES = ('', 'Choisissez votre bibliothèque'),('checker','checker'),
    if Library.objects.using(bdd).all().exclude(name ='checker'):
        for l in Library.objects.using(bdd).all().exclude(name ='checker').order_by('name'):
            LIBRARY_CHOICES += (l.name, l.name),

    class FeatureForm(forms.ModelForm):
        class Meta:
            model = Feature
            fields = ('libname', 'feaname',)
            widgets = {
                'libname' : forms.Select(choices=LIBRARY_CHOICES),
                'feaname' : forms.RadioSelect(choices=FEATURE_CHOICES),
            }

    #Feature input :
    i = Feature()

    form = FeatureForm(request.POST, instance =i)

    if form.is_valid():
        lid = Library.objects.using(bdd).get(name =i.libname).lid
        feature =i.feaname
        if not Feature.objects.using(bdd).filter(feaname =feature, libname =i.libname):
            i.save(using=bdd)

        if lid =="999999999":
            if feature =='instrtodo':
                return instrtodo(request, bdd, lid, 'title')
            else:
                return checkinstr(request, bdd)
        else:
            if feature =='ranking':
                return ranktotake(request, bdd, lid, 'title')
            elif feature =='arbitration':
                return arbitration(request, bdd, lid, 'title')
            elif feature =='instrtodo':
                return instrtodo(request, bdd, lid, 'title')
            elif feature =='edition':
                return tobeedited(request, bdd, lid, 'title')

    #abstract :
    usernbr =len(Utilisateur.objects.using(bdd).all())
    librnbr =len(Library.objects.using(bdd).all()) -1  #checkers are not libraries ! (one checker per project)
    itemrecnbr =len(ItemRecord.objects.using(bdd).all())
    instrnbr =len(Instruction.objects.using(bdd).all())
    cand =[]
    for e in ItemRecord.objects.using(bdd).all():
        if len(ItemRecord.objects.using(bdd).filter(sid =e.sid)) >1 and not e.sid in cand:
            cand.append(e.sid)
    totcand =len(cand)

    return render(request, 'epl/home.html', locals())

@login_required
def adminbase(request, bdd):

    #contrôle d'accès ici
    if not len(BddAdmin.objects.using(bdd).filter(contact =request.user.email)):
        messages.info(request, _("Vous avez été renvoyé à cette page parce que vous n'avez pas les droits d'accès à la page que vous demandiez"))
        return home(request, bdd)

    k =logstatus(request)
    version =epl_version
    url ="/" + bdd + "/adminbase"
    suffixe = "@" + str(bdd)

    EXCLUSION_CHOICES = ('', ''),
    for e in Exclusion.objects.using(bdd).all().order_by('label'):
        EXCLUSION_CHOICES += (e.label, e.label),
    EXCLUSION_CHOICES += ("Autre (Commenter)", _("Autre (Commenter)")),
    exclnbr =len(EXCLUSION_CHOICES) -1
    project = Project.objects.using(bdd).all().order_by('pk')[0].name
    abstract =Project.objects.using(bdd).all().order_by('pk')[0].descr
    extractdate =Project.objects.using(bdd).all().order_by('pk')[0].date

    #Stuff about project
    class ProjNameForm(forms.Form):
        projname = forms.CharField(required =True, widget=forms.TextInput(attrs={'size': '30'}), max_length=30, label =_("project code name"))
    class ProjDescrForm(forms.Form):
        projdescr =forms.CharField(required =True, widget=forms.Textarea(attrs={'rows':1, 'cols':50},), max_length=300, label =_("project description"))
    class ProjDateForm(forms.Form):
        projdate =forms.CharField(required =True, widget=forms.TextInput(attrs={'size': '50'}), max_length=50, label =_("database extraction date"))
    projnamform = ProjNameForm(request.POST or None)
    projdescform = ProjDescrForm(request.POST or None)
    projdateform = ProjDateForm(request.POST or None)

    if projnamform.is_valid():
        prj =Project.objects.using(bdd).all().order_by('pk')[0]
        prj.name =projnamform.cleaned_data['projname']
        prj.save(using =bdd)
        messages.info(request, _("Le nom du projet a été modifié avec succès"))
        # return HttpResponseRedirect(url)

    if projdescform.is_valid():
        prj =Project.objects.using(bdd).all().order_by('pk')[0]
        prj.descr =projdescform.cleaned_data['projdescr']
        prj.save(using =bdd)
        messages.info(request, _("Le résumé du projet a été modifié avec succès"))
        # return HttpResponseRedirect(url)

    if projdateform.is_valid():
        prj =Project.objects.using(bdd).all().order_by('pk')[0]
        prj.date =projdateform.cleaned_data['projdate']
        prj.save(using =bdd)
        messages.info(request, _("La date d'extraction de la base a été modifiée avec succès"))
        # return HttpResponseRedirect(url)

    #Stuff about exclusions
    class ExcluForm(forms.Form):
        exclusup = forms.CharField(required =True, widget=forms.TextInput(attrs={'size': '30'}), max_length=30, label =_("exclusion suppl"))
    exclform =ExcluForm(request.POST or None)
    class ExcluSupprForm(forms.Form):
        exclreason = forms.ChoiceField(required = True, widget=forms.Select, choices=EXCLUSION_CHOICES[:-1], label =_("Motif d'exclusion à supprimer"))
        exclmod = forms.CharField(required =False, widget=forms.TextInput(attrs={'size': '30'}), max_length=30, label =_("exclusion modifiée"))
        suppr = forms.BooleanField(required=False)
    exclsupprform =ExcluSupprForm(request.POST or None)

    if exclform.is_valid():
        try:
            op =Exclusion.objects.using(bdd).get(label =exclform.cleaned_data['exclusup'])
            messages.info(request, _('Cette exclusion existe déjà'))
            # return HttpResponseRedirect(url)
        except:
            newexcl =Exclusion()
            newexcl.label =exclform.cleaned_data['exclusup']
            newexcl.save(using =bdd)
            messages.info(request, _('Exclusion ajoutée avec succès'))
            # return HttpResponseRedirect(url)
    if exclsupprform.is_valid():
        op =Exclusion.objects.using(bdd).get(label =exclsupprform.cleaned_data['exclreason'])
        if exclsupprform.cleaned_data['suppr'] ==True:
            if len(ItemRecord.objects.using(bdd).filter(excl =exclsupprform.cleaned_data['exclreason'])):
                messages.info(request, _('Suppression impossible : Cete exclusion a déjà servi (vous pouvez éventuellement modifier son intitulé)'))
            else:
                op.delete(using =bdd)
                messages.info(request, _('Exclusion supprimée avec succès'))
        else:
            if exclsupprform.cleaned_data['exclmod']:
                for it in ItemRecord.objects.using(bdd).filter(excl =exclsupprform.cleaned_data['exclreason']):
                    if it.excl ==exclsupprform.cleaned_data['exclreason']:
                        it.excl =exclsupprform.cleaned_data['exclmod']
                        it.save(using =bdd)
                op.label =exclsupprform.cleaned_data['exclmod']
                op.save(using =bdd)
                messages.info(request, _('Exclusion modifiée avec succès'))
            else:
                messages.info(request, _("Vous n'avez pas complété le formulaire correctement"))


    #Stuff about libraries
    LIBRARY_CHOICES = ('', _('Sélectionnez la bibliothèque')), ('checker', 'checker'),
    if Library.objects.using(bdd).all().exclude(name ='checker'):
        for l in Library.objects.using(bdd).all().exclude(name ='checker').order_by('name'):
            LIBRARY_CHOICES += (l.name, l.name),

    CONTACT_CHOICE =('', _('Contact')), ('1', '1'), ('2', '2'), ('3', '3'),

    class LibrMCurNameForm(forms.Form):
        curname = forms.ChoiceField(required = True, widget=forms.Select, choices=LIBRARY_CHOICES, label =_("bibliothèque"))
        # curname = forms.CharField(required =True, widget=forms.TextInput(attrs={'size': '30'}), max_length=30, label =_("nom de la bib"))
    class LibrMNewNameForm(forms.Form):
        newlibrname = forms.CharField(required =True, widget=forms.TextInput(attrs={'size': '30', 'title': _("Action rétroactive applicable à l'ensemble des instructions")}), max_length=30, label =_("nom de la bib"))
    class LibrMCtcForm(forms.Form):
        name = forms.ChoiceField(required = True, widget=forms.Select, choices=LIBRARY_CHOICES, label =_("bibliothèque"))
        # name = forms.CharField(required =True, widget=forms.TextInput(attrs={'size': '30'}), max_length=30, label =_("nom de la bib"))
        contactnbr =forms.ChoiceField(required = True, widget=forms.Select, choices=CONTACT_CHOICE)
        contact = forms.EmailField(required =False, label ='email 1')
        ident = forms.CharField(required =False, widget=forms.TextInput(attrs=\
        {'placeholder': "Oriane@" + bdd, 'title': _("Suffixe obligatoire") + \
        ' : ' + '@' + bdd + '. ' + \
        _("Saisissez un nom d'utilisateur valide. Il ne peut contenir que des lettres, des nombres ou les caractères « @ », « . », « + », « - » et « _ ».")}), \
        max_length=30, label =_("identifiant 1"))
        suppr = forms.BooleanField(required=False)

    liblist =Library.objects.using(bdd).exclude(name ='checker')
    sizelib =len(liblist)
    try:
        bis = Utilisateur.objects.using(bdd).get(mail =Library.objects.using(bdd).get(name ='checker').contact_bis)
    except:
        bis =None
    try:
        ter = Utilisateur.objects.using(bdd).get(mail =Library.objects.using(bdd).get(name ='checker').contact_ter)
    except:
        ter =None

    libtuple =(Library.objects.using(bdd).get(name ='checker'), Utilisateur.objects.using(bdd).get(mail =Library.objects.using(bdd).get(name ='checker').contact), bis, ter),
    for libelmt in liblist:
        try:
            bis = Utilisateur.objects.using(bdd).get(mail =Library.objects.using(bdd).get(name =libelmt.name).contact_bis)
        except:
            bis =None
        try:
            ter = Utilisateur.objects.using(bdd).get(mail =Library.objects.using(bdd).get(name =libelmt.name).contact_ter)
        except:
            ter =None
        libtuple +=(Library.objects.using(bdd).get(name =libelmt.name), Utilisateur.objects.using(bdd).get(mail =Library.objects.using(bdd).get(name =libelmt.name).contact), bis, ter),

    formlibname = LibrMCurNameForm(request.POST or None)
    formnewlibname = LibrMNewNameForm(request.POST or None)
    formlibct = LibrMCtcForm(request.POST or None)

    if formlibname.is_valid() and formnewlibname.is_valid():
        if not formlibname.cleaned_data['curname'] ==formnewlibname.cleaned_data['newlibrname']:
            if formlibname.cleaned_data['curname'] =='checker' or formnewlibname.cleaned_data['newlibrname'] =='checker':
                messages.info(request, _("'checker' est un nom réservé"))
                # return HttpResponseRedirect(url)
            else:
                try:
                    bibliot =Library.objects.using(bdd).get(name =formlibname.cleaned_data['curname'])
                    curname = formlibname.cleaned_data['curname']
                    newname = formnewlibname.cleaned_data['newlibrname']
                    for insn in Instruction.objects.using(bdd).filter(name =curname):
                        insn.name =newname
                        insn.save(using =bdd)
                    for inso in Instruction.objects.using(bdd).filter(oname =curname):
                        inso.oname =newname
                        inso.save(using =bdd)
                    lib = Library.objects.using(bdd).get(name =curname)
                    lib.name =formnewlibname.cleaned_data['newlibrname']
                    lib.save(using =bdd)
                    messages.info(request, _("Nom de la bibliothèque modifié avec succès"))
                    # return HttpResponseRedirect(url)
                except:
                    pass
                    # messages.info(request, _("Pas de bibliothèque au nom que vous avez indiqué"))
                    # return HttpResponseRedirect(url)

    BDD_CHOICES =('', ''),
    for i in [n for n in range(100)]:
        if os.path.isfile('{:02d}.db'.format(i)):
            p = Project.objects.using('{:02d}'.format(i)).all().order_by('pk')[0].name
            BDD_CHOICES += ('{:02d}'.format(i), p),
    BDD_CHOICES =BDD_CHOICES[1:]

    if formlibct.is_valid():
        try:
            if Library.objects.using(bdd).get(name =formlibct.cleaned_data['name']) in Library.objects.using(bdd).all():
                lib = Library.objects.using(bdd).get(name =formlibct.cleaned_data['name'])
                if formlibct.cleaned_data['suppr'] ==True:
                    compteura =0
                    if formlibct.cleaned_data['contactnbr'] =='2':
                        try:
                            for u in Library.objects.using(bdd).all():
                                if u.contact ==lib.contact_bis:
                                    compteura +=1
                                if u.contact_bis ==lib.contact_bis:
                                    compteura +=1
                                if u.contact_ter ==lib.contact_bis:
                                    compteura +=1
                            for v in BddAdmin.objects.using(bdd).all():
                                if v.contact ==lib.contact_bis:
                                    compteura +=1
                            if compteura ==1:
                                user =User.objects.get(username =Utilisateur.objects.using(bdd).get(mail =lib.contact_bis).username)
                                uter =Utilisateur.objects.using(bdd).get(mail =lib.contact_bis)
                                user.delete()
                                uter.delete()
                            lib.contact_bis =None
                            lib.save(using =bdd)
                            messages.info(request, _('Contact supprimé avec succès'))
                        except:
                            messages.info(request, _("(Le contact était déjà vacant)"))

                    compteurb =0
                    if formlibct.cleaned_data['contactnbr'] =='3':
                        try:
                            for u in Library.objects.using(bdd).all():
                                if u.contact ==lib.contact_ter:
                                    compteurb +=1
                                if u.contact_bis ==lib.contact_ter:
                                    compteurb +=1
                                if u.contact_ter ==lib.contact_ter:
                                    compteurb +=1
                            for v in BddAdmin.objects.using(bdd).all():
                                if v.contact ==lib.contact_ter:
                                    compteurb +=1
                            if compteurb ==1:
                                user =User.objects.get(username =Utilisateur.objects.using(bdd).get(mail =lib.contact_ter).username)
                                uter =Utilisateur.objects.using(bdd).get(mail =lib.contact_ter)
                                user.delete()
                                uter.delete()
                            lib.contact_ter =None
                            lib.save(using =bdd)
                            messages.info(request, _('Contact supprimé avec succès'))
                        except:
                            messages.info(request, _("(Le contact était déjà vacant)"))
                        # return HttpResponseRedirect(url)
                    if formlibct.cleaned_data['contactnbr'] =='1':
                        messages.info(request, _('Le contact principal ne peut pas être supprimé'))
                        # return HttpResponseRedirect(url)
                else:#formlibct.cleaned_data['suppr'] ==False
                    if not formlibct.cleaned_data['ident'] and formlibct.cleaned_data['contact']:
                        messages.info(request, _("Echec : Vous avez omis l'identifiant"))
                    elif formlibct.cleaned_data['ident'] and not formlibct.cleaned_data['contact']:
                        messages.info(request, _("Echec : Vous avez omis l'email"))
                    else:#Formulaire complet
                        try:#utilisateur déjà présent dans la base
                            uter =Utilisateur.objects.using(bdd).get(username =formlibct.cleaned_data['ident'], mail =formlibct.cleaned_data['contact'])
                            if formlibct.cleaned_data['contactnbr'] =='1':
                                lib.contact =formlibct.cleaned_data['contact']
                                lib.save(using =bdd)
                            if formlibct.cleaned_data['contactnbr'] =='2':
                                lib.contact_bis =formlibct.cleaned_data['contact']
                                lib.save(using =bdd)
                            if formlibct.cleaned_data['contactnbr'] =='3':
                                lib.contact_ter =formlibct.cleaned_data['contact']
                                lib.save(using =bdd)
                                messages.info(request, _("Modification effectuée avec succès (réemploi d'un utilisateur déjà présent dans la base)"))
                                # return HttpResponseRedirect(url)
                        except:#utilisateur absent de la base
                            if len(Utilisateur.objects.using(bdd).filter(username =formlibct.cleaned_data['ident'])):
                                messages.info(request, _("Echec : l'identifiant est déjà attribué à un autre utilisateur"))
                            elif len(Utilisateur.objects.using(bdd).filter(mail =formlibct.cleaned_data['contact'])):
                                messages.info(request, _("Echec : l'email est déjà attribué à un autre utilisateur"))
                            else:
                                if str(formlibct.cleaned_data['ident'])[-3:] !=suffixe:
                                    messages.info(request, _("Echec : L'identifiant doit se terminer en {}".format(suffixe)))
                                else:
                                    try:
                                        user =User.objects.create_user(username =formlibct.cleaned_data['ident'], email =formlibct.cleaned_data['contact'], password ="glass onion")
                                        uter =Utilisateur(username =formlibct.cleaned_data['ident'], mail =formlibct.cleaned_data['contact'])
                                        uter.save(using =bdd)
                                        if formlibct.cleaned_data['contactnbr'] =='1':
                                            lib.contact =formlibct.cleaned_data['contact']
                                            lib.save(using =bdd)
                                        if formlibct.cleaned_data['contactnbr'] =='2':
                                            lib.contact_bis =formlibct.cleaned_data['contact']
                                            lib.save(using =bdd)
                                        if formlibct.cleaned_data['contactnbr'] =='3':
                                            lib.contact_ter =formlibct.cleaned_data['contact']
                                            lib.save(using =bdd)
                                        messages.info(request, _("Modification effectuée avec succès (un nouvel utilisateur a été créé)"))
                                    except:
                                        messages.info(request, _("L'identifiant ne respecte pas le format prescrit"))
        except:
            pass

    #Stuff about bddadministrators
    admintuple =('', "Sélectionnez l'administrateur"),
    for b in BddAdmin.objects.using(bdd).all():
        admintuple +=(b.contact, Utilisateur.objects.using(bdd).get(mail =BddAdmin.objects.using(bdd).get(contact =b.contact).contact)),
    admintup =admintuple[1:]
    sizeadm =len(BddAdmin.objects.using(bdd).all())

    class ProjadmAjForm(forms.Form):
        contactajadm = forms.EmailField(required =True, label ='current email')
        identajadm = forms.CharField(required =True, widget=forms.TextInput(attrs=\
        {'placeholder': "Rosemonde@" + bdd, 'title': _("Suffixe obligatoire") + \
        ' : ' + '@' + bdd + '. ' + \
        "Saisissez un nom d'utilisateur valide. Il ne peut contenir que des lettres, des nombres ou les caractères « @ », « . », « + », « - » et « _ »."}), \
        max_length=30, label =_("identifiant"))

    projajadmform =ProjadmAjForm(request.POST or None)

    class ProjadmSupprForm(forms.Form):
        contactsuadm = forms.ChoiceField(required = True, widget=forms.Select, choices=admintuple, label =_("email courant"))
        suppradm = forms.BooleanField(required=True)

    projsuppradmform =ProjadmSupprForm(request.POST or None)

    if projajadmform.is_valid():
        try:
            newadm =BddAdmin.objects.using(bdd).get(contact =projajadmform.cleaned_data['contactajadm'])
            messages.info(request, _("(Administrateur déjà enregistré)"))
        except:
            try:
                uter =Utilisateur.objects.using(bdd).get(username =projajadmform.cleaned_data['identajadm'], mail =projajadmform.cleaned_data['contactajadm'])
                newadm =BddAdmin(contact =projajadmform.cleaned_data['contactajadm'])
                newadm.save(using =bdd)
                messages.info(request, _("Administrateur ajouté avec succès (réemploi d'un utilisateur déjà présent dans la base)"))
            except:
                try:
                    uter =Utilisateur.objects.using(bdd).get(username =projajadmform.cleaned_data['identajadm'])
                    messages.info(request, _("Echec : L'identifiant saisi est déjà utilisé"))
                except:
                    try:
                        uter =Utilisateur.objects.using(bdd).get(mail =projajadmform.cleaned_data['contactajadm'])
                        messages.info(request, _("Echec : L'email saisi est déjà utilisé"))
                    except:
                        if str(projajadmform.cleaned_data['identajadm'])[-3:] !=suffixe:
                            messages.info(request, _("Echec : L'identifiant doit se terminer en {}".format(suffixe)))
                        else:
                            try:
                                uter =Utilisateur(username =projajadmform.cleaned_data['identajadm'], mail =projajadmform.cleaned_data['contactajadm'])
                                user =User.objects.create_user(username =projajadmform.cleaned_data['identajadm'], email =projajadmform.cleaned_data['contactajadm'], password ="glass onion")
                                uter.save(using =bdd)
                                newadm =BddAdmin(contact =projajadmform.cleaned_data['contactajadm'])
                                newadm.save(using =bdd)
                                messages.info(request, _("Administrateur ajouté avec succès (un nouvel utilisateur a été créé)"))
                            except:
                                messages.info(request, _("Echec : L'identifiant ne respecte pas le format prescrit"))

    if projsuppradmform.is_valid():
        if len(BddAdmin.objects.using(bdd).all()) ==1:
            messages.info(request, _("Vous ne pouvez pas supprimer le dernier administrateur restant"))
        else:
            suppradm =BddAdmin.objects.using(bdd).get(contact =projsuppradmform.cleaned_data['contactsuadm'])
            compteurc =0
            for u in Library.objects.using(bdd).all():
                if u.contact ==suppradm.contact:
                    compteurc +=1
                if u.contact_bis ==suppradm.contact:
                    compteurc +=1
                if u.contact_ter ==suppradm.contact:
                    compteurc +=1
            for v in BddAdmin.objects.using(bdd).all():
                if v.contact ==suppradm.contact:
                    compteurc +=1
            if compteurc ==1:
                user =User.objects.get(username =Utilisateur.objects.using(bdd).get(mail =projsuppradmform.cleaned_data['contactsuadm']).username)
                uter =Utilisateur.objects.using(bdd).get(mail =projsuppradmform.cleaned_data['contactsuadm'])
                user.delete()
                uter.delete()
            suppradm.delete(using =bdd)
            messages.info(request, _('Administrateur supprimé avec succès'))

    #Stuff about utilisateurs :
    uterstuple =('', "Sélectionnez l'utilisateur"),
    for u in Utilisateur.objects.using(bdd).all().order_by("username"):
        uterstuple +=(u.mail, Utilisateur.objects.using(bdd).get(mail =u.mail)),
    sizeuters =len(Utilisateur.objects.using(bdd).all())

    class UtModForm(forms.Form):
        uterxy = forms.ChoiceField(required = True, widget=forms.Select, choices=uterstuple, label =_("Utilisateur"))
        newuterid = forms.CharField(required =False, widget=forms.TextInput(attrs=\
        {'placeholder': "Marcel@" + bdd, 'title': _("Suffixe obligatoire") + \
        ' : ' + '@' + bdd + '. ' + \
        "Saisissez un nom d'utilisateur valide. Il ne peut contenir que des lettres, des nombres ou les caractères « @ », « . », « + », « - » et « _ »."}), \
        max_length=30, label =_("nouvel identifiant de l'utilisateur"))
        newutermail = forms.EmailField(required =False, label ="nouvel email de l'utilisateur")

    utermodform =UtModForm(request.POST or None)

    if utermodform.is_valid():
        if utermodform.cleaned_data['newuterid'] and utermodform.cleaned_data['newutermail']:
            messages.info(request, _("Echec : Ne complétez qu'un des arguments à la fois"))
        else:
            try:
                uter =Utilisateur.objects.using(bdd).get(mail =utermodform.cleaned_data['newutermail'])
                messages.info(request, _("Echec : L'email saisi est déjà utilisé"))
            except:
                try:
                    uter =Utilisateur.objects.using(bdd).get(username =utermodform.cleaned_data['newuterid'])
                    messages.info(request, _("Echec : L'identifiant saisi est déjà utilisé"))
                except:
                    if utermodform.cleaned_data['newuterid']:
                        if str(utermodform.cleaned_data['newuterid'])[-3:] !=suffixe:
                            messages.info(request, _("Echec : L'identifiant doit se terminer en {}".format(suffixe)))
                        else:
                            try:
                                uter =Utilisateur.objects.using(bdd).get(mail =utermodform.cleaned_data['uterxy'])
                                uter.username =utermodform.cleaned_data['newuterid']
                                user =User.objects.get(username =Utilisateur.objects.using(bdd).get(mail =utermodform.cleaned_data['uterxy']).username)
                                user.username =utermodform.cleaned_data['newuterid']
                                uter.save(using =bdd)
                                user.save()
                                messages.info(request, _("L'identifiant de l'utilisateur a été modifié avec succès"))
                            except:
                                messages.info(request, _("L'identifiant ne respecte pas le format prescrit"))
                    elif utermodform.cleaned_data['newutermail']:
                        try:
                            uter =Utilisateur.objects.using(bdd).get(mail =utermodform.cleaned_data['uterxy'])
                            uter.mail =utermodform.cleaned_data['newutermail']
                            user =User.objects.get(username =Utilisateur.objects.using(bdd).get(mail =utermodform.cleaned_data['uterxy']).username)
                            for l in Library.objects.using(bdd).all():
                                if l.contact ==utermodform.cleaned_data['uterxy']:
                                    l.contact =utermodform.cleaned_data['newutermail']
                                if l.contact_bis ==utermodform.cleaned_data['uterxy']:
                                    l.contact_bis =utermodform.cleaned_data['newutermail']
                                if l.contact_ter ==utermodform.cleaned_data['uterxy']:
                                    l.contact_ter =utermodform.cleaned_data['newutermail']
                                l.save(using =bdd)
                            if BddAdmin.objects.using(bdd).filter(contact =utermodform.cleaned_data['uterxy']):
                                adm =BddAdmin.objects.using(bdd).get(contact =utermodform.cleaned_data['uterxy'])
                                adm.contact =utermodform.cleaned_data['newutermail']
                                adm.save(using =bdd)
                            uter.save(using =bdd)
                            user.save()
                            messages.info(request, _("L'email de l'utilisateur a été modifié avec succès"))
                        except:
                            pass



    # (la suppression éventuelle de l'utilisateur et du user est factorisée en fin de vue) ????

    # messages.debug(request, '%s SQL statements were executed.' % count)
    # messages.info(request, 'Three credits remain in your account.')
    # messages.success(request, 'Profile details updated.')
    # messages.warning(request, 'Your account expires in three days.')
    # messages.error(request, 'Document deleted.')
    # messages.info(request, 'Hello world.')
    # messages.info(request, messages.SUCCESS, 'Hello wolafùlrld.')

    if request.method =="POST":
        return HttpResponseRedirect(url)
    else:#request.method =="GET
    #La partie de code ci-dessous est reproduite dans la vue home(request, bdd) = Synchronisation de la base locale (utilisateurs) avec la base générale (users)
        for e in Utilisateur.objects.using(bdd).all():#1/2 création d'éventuels nouveaux users dans la base générale
            try:
                user =User.objects.get(username =e.username)
            except:
                user =User.objects.create_user(username =e.username, email =e.mail, password ="glass onion")

        #2/2 (see upper, this order is important)
        suffixe = "@" + str(bdd)
        for j in User.objects.all(): #Suppression d'users pour lesquels l'utilisateur a été supprimé de la base locale
            if j.username[-3:] ==suffixe:
                try:
                    utilisateur =Utilisateur.objects.using(bdd).get(username =j.username)
                except:
                    j.delete() #suppression dans la bdd générale

    return render(request, 'epl/adminbase.html', locals())

@login_required
def globadm(request):

    """Global administration"""

    #contrôle d'accès ici
    if not request.user.is_staff:
        messages.info(request, _("Vous avez été renvoyé à cette page parce que vous n'avez pas les droits d'accès à la page que vous demandiez"))
        return selectbdd(request)

    k =logstatus(request)
    version =epl_version
    date =date_version
    host = str(request.get_host())

    return render(request, 'epl/globadm.html', locals())



def about(request):

    k =logstatus(request)
    version =epl_version
    date =date_version
    host = str(request.get_host())
    return render(request, 'epl/about.html', locals())


def contact(request):

    k =logstatus(request)
    version =epl_version
    date =date_version
    host = str(request.get_host())

    class ContactForm(forms.Form):
        object_list = (("Demande d'information", _("Demande d'information")), ("Bug", _("Bug")),\
         ("Réclamation", _("Réclamation")), ("Suggestion", _("Suggestion")), ("Avis", _("Avis")),  ("Autre", _("Autre")))
        object = forms.ChoiceField(required = True, widget=forms.Select, choices=object_list, label =_("Objet"))
        email = forms.EmailField(required = True, label =_("Votre adresse mail de contact"))
        email_confirm =forms.EmailField(required = True, label =_("Confirmation de l'adresse mail"))
        content = forms.CharField(required=True, widget=forms.Textarea, label =_("Votre message"))

    form = ContactForm(request.POST or None)
    if form.is_valid():
        recipient = form.cleaned_data['email']
        recipient_confirm = form.cleaned_data['email_confirm']
        subject2 = form.cleaned_data['object']
        body = form.cleaned_data['content']
        if recipient ==recipient_confirm:
            subject2 = "[eplouribousse]" + " - " + subject2
            subject1 = subject2 + " - " + version + " - " + host
            message1 = subject1 + " :\n" + "\n" + body
            message2 = _("Votre message a bien été envoyé au développeur de l'application qui y répondra prochainement")\
             + ".\n" + _("Ne répondez pas au présent mail s'il vous plaît") + ".\n" + \
             "Rappel de l'objet de votre message" + " : " + subject2 + \
             "\n" + _("Rappel de votre message") + " :\n" + \
              _("***** Début *****") + "\n" + _("Objet") +  " : " + subject2 + \
              "\n" + _("Corps") + " : " + "\n" + body + "\n" + _("*****  Fin  *****")
            dest1 = ["eplouribousse@gmail.com"]
            dest2 = [recipient]
            send_mail(subject1, message1, recipient, dest1, fail_silently=True, )
            send_mail(subject2, message2, replymail, dest2, fail_silently=True, )
            return render(request, 'epl/confirmation.html', locals())
        else:
            info =_("Attention : Les adresses doivent être identiques") + "."
    else:
        if request.method =="POST":
            info =_("Vérifier que les adresses sont correctes") + "."

    return render(request, 'epl/contact.html', locals())




def webmstr(request):

    k =logstatus(request)
    version =epl_version
    date =date_version
    host = str(request.get_host())

    class ContactForm(forms.Form):
        object_list = (("Demande d'information", _("Demande d'information")), ("Bug", _("Bug")),\
         ("Réclamation", _("Réclamation")), ("Suggestion", _("Suggestion")), ("Avis", _("Avis")),  ("Autre", _("Autre")))
        object = forms.ChoiceField(required = True, widget=forms.Select, choices=object_list, label =_("Objet"))
        email = forms.EmailField(required = True, label =_("Votre adresse mail de contact"))
        email_confirm =forms.EmailField(required = True, label =_("Confirmation de l'adresse mail"))
        content = forms.CharField(required=True, widget=forms.Textarea, label =_("Votre message"))

    form = ContactForm(request.POST or None)
    if form.is_valid():
        recipient = form.cleaned_data['email']
        recipient_confirm = form.cleaned_data['email_confirm']
        subject2 = form.cleaned_data['object']
        body = form.cleaned_data['content']
        if recipient ==recipient_confirm:
            subject2 = "[eplouribousse]" + " - " + subject2
            subject1 = subject2 + " - " + version + " - " + host
            message1 = subject1 + " :\n" + "\n" + body
            message2 = _("Votre message a bien été envoyé au webmaster qui y répondra prochainement")\
             + ".\n" + _("Ne répondez pas au présent mail s'il vous plaît") + ".\n" \
             + _("Rappel de votre message") + " :\n" + \
             _("***** Début *****") + "\n" + _("Objet") +  " : " + subject2 + \
             "\n" + _("Corps") + " : " + "\n" + body + "\n" + _("*****  Fin  *****")
            dest1 = [webmaster]
            dest2 = [recipient]
            send_mail(subject1, message1, recipient, dest1, fail_silently=True, )
            send_mail(subject2, message2, replymail, dest2, fail_silently=True, )
            return render(request, 'epl/confirmation.html', locals())
        else:
            info =_("Attention : Les adresses doivent être identiques") + "."
    else:
        if request.method =="POST":
            info =_("Vérifier que les adresses sont correctes") + "."

    return render(request, 'epl/webmaster.html', locals())


def projmstr(request, bdd):

    k =logstatus(request)
    version =epl_version
    date =date_version
    host = str(request.get_host())
    project = Project.objects.using(bdd).all().order_by('pk')[0].name
    dest1 =[]
    for bddadm in BddAdmin.objects.using(bdd).all():
        dest1.append(bddadm.contact)

    class ContactForm(forms.Form):
        object_list = (("Signalement d'une anomalie", _("Signalement d'une anomalie")), \
        ("Modification des infos projet (nom, résumé, date d'extraction)", _("Modification des infos projet (nom, résumé, date d'extraction)")), \
        ("Ajout, modification ou suppression de motifs d'exclusion", _("Ajout, modification ou suppression de motifs d'exclusion")),\
         ("Ajout, modification ou suppression de correspondants d'une bibliothèque", _("Ajout, modification ou suppression de correspondants d'une bibliothèque")), \
         ("Ajout, modification ou suppression d'administrateurs", _("Ajout, modification ou suppression d'administrateurs")), \
         ("Ajout, modification ou suppression d'utilisateurs", _("Ajout, modification ou suppression d'utilisateurs")), \
         ("Info d'un des administrateurs du projet à ses co-administrateurs", _("Info d'un des administrateurs du projet à ses co-administrateurs")), \
         ("Autre", _("Autre")))
        object = forms.ChoiceField(required = True, widget=forms.Select, choices=object_list, label =_("Objet"))
        email = forms.EmailField(required = True, label =_("Votre adresse mail de contact"))
        email_confirm =forms.EmailField(required = True, label =_("Confirmation de l'adresse mail"))
        content = forms.CharField(required=True, widget=forms.Textarea, label =_("Votre message"))

    form = ContactForm(request.POST or None)
    if form.is_valid():
        recipient = form.cleaned_data['email']
        recipient_confirm = form.cleaned_data['email_confirm']
        subject2 = form.cleaned_data['object']
        body = form.cleaned_data['content']
        if recipient ==recipient_confirm:
            subject2 = "[eplouribousse]" + " - " + subject2
            subject1 = subject2 + " - " + version + " - " + host
            message1 = subject1 + " :\n" + "\n" + body
            message2 = _("Votre message a bien été envoyé à l'administrateur du projet qui y répondra prochainement")\
             + ".\n" + _("Ne répondez pas au présent mail s'il vous plaît") + ".\n" \
             + _("Rappel de votre message") + " :\n" + \
             _("***** Début *****") + "\n" + _("Objet") +  " : " + subject2 + \
             "\n" + _("Corps") + " : " + "\n" + body + "\n" + _("*****  Fin  *****")
            dest2 = [recipient]
            send_mail(subject1, message1, recipient, dest1, fail_silently=True, )
            send_mail(subject2, message2, replymail, dest2, fail_silently=True, )
            return render(request, 'epl/confirmation.html', locals())
        else:
            info =_("Attention : Les adresses doivent être identiques") + "."
    else:
        if request.method =="POST":
            info =_("Vérifier que les adresses sont correctes") + "."

    return render(request, 'epl/projmaster.html', locals())


def confirm(request):

    k =logstatus(request)
    version =epl_version

    return render(request, 'epl/confirmation.html', locals())


def router(request, bdd, lid):

    if not Feature.objects.using(bdd).filter(libname =Library.objects.using(bdd).get(lid =lid).name).exclude(feaname = "ranking").exclude(feaname ="arbitration").exclude(feaname ="instrtodo").exclude(feaname ="edition"):
        return home(request, bdd)
    else:
        newestfeature =Feature.objects.using(bdd).filter(libname =Library.objects.using(bdd).get(lid =lid).name).exclude(feaname = "ranking").exclude(feaname ="arbitration").exclude(feaname ="instrtodo").exclude(feaname ="edition")[0]
        key =newestfeature.feaname.split('$')
        if key[0] =="10":
            return ranktotake(request, bdd, lid, 'title')
        elif key[0] =="11":
            return xranktotake(request, bdd, lid, key[1], 'title')
        elif key[0] =="12":
            return modifranklist(request, bdd, lid, 'title')
        elif key[0] =="20":
            return arbitration(request, bdd, lid, 'title')
        elif key[0] =="21":
            return xarbitration(request, bdd, lid, key[1], 'title')
        elif key[0] =="22":
            return x1arb(request, bdd, lid, key[1], 'title')
        elif key[0] =="23":
            return x0arb(request, bdd, lid, key[1], 'title')
        elif key[0] =="24":
            return arbrk1(request, bdd, lid, 'title')
        elif key[0] =="25":
            return arbnork1(request, bdd, lid, 'title')
        elif key[0] =="30":
            return instrtodo(request, bdd, lid, 'title')
        elif key[0] =="31":
            return xinstrlist(request, bdd, lid, key[1], 'title')
        elif key[0] =="32":
            return xckbd(request, bdd, eval(key[1]))
        elif key[0] =="33":
            return xcknbd(request, bdd, eval(key[1]))
        elif key[0] =="34":
            return xckall(request, bdd, eval(key[1]))
        elif key[0] =="35":
            return instroneb(request, bdd, lid, 'title')
        elif key[0] =="36":
            return instrotherb(request, bdd, lid, 'title')
        elif key[0] =="37":
            return instronenotb(request, bdd, lid, 'title')
        elif key[0] =="38":
            return instrothernotb(request, bdd, lid, 'title')
        elif key[0] =="40":
            return tobeedited(request, bdd, lid, 'title')
        elif key[0] =="41":
            return mothered(request, bdd, lid, 'title')
        elif key[0] =="42":
            return notmothered(request, bdd, lid, 'title')
        elif key[0] =="43":
            return xmothered(request, bdd, lid, key[1], 'title')
        elif key[0] =="44":
            return xnotmothered(request, bdd, lid, key[1], 'title')

    return render(request, 'epl/router.html', locals())


def lang(request):
    k =logstatus(request)
    version =epl_version

    return render(request, 'epl/language.html', locals())


def logout_view(request):

    "Homepage special disconnected"

    logout(request)

    # Redirect to a success page.

    version =epl_version

    return render(request, 'epl/disconnect.html', locals())


def notintime(request, bdd, sid, lid):

    k =logstatus(request)
    version =epl_version

    library = Library.objects.using(bdd).get(lid = lid).name
    if lid =="999999999":
        try:
            title = ItemRecord.objects.using(bdd).get(sid =sid, rank =1).title
        except:
            title = sid
    else:
        title = ItemRecord.objects.using(bdd).get(sid =sid, lid =lid).title
    return render(request, 'epl/notintime.html', locals())


def indicators(request, bdd):

    k =logstatus(request)
    version =epl_version

    #Indicators :

    #Number of rankings (exclusions included) :
    rkall = len(ItemRecord.objects.using(bdd).exclude(rank =99))

    #Number of rankings (exclusions excluded) :
    rkright = len(ItemRecord.objects.using(bdd).exclude(rank =99).exclude(rank =0))

    #Number of exclusions (collections) :
    exclus = len(ItemRecord.objects.using(bdd).filter(rank =0))

    #number of libraries :
    nlib = len(Library.objects.using(bdd).all())

    #Exclusions details
    dict ={}
    EXCLUSION_CHOICES = ('', ''),
    for e in Exclusion.objects.using(bdd).all().order_by('label'):
        EXCLUSION_CHOICES += (e.label, e.label),
    EXCLUSION_CHOICES += ("Autre (Commenter)", _("Autre (Commenter)")),
    for e in EXCLUSION_CHOICES:
        exclusion =str(e[0])
        value =len(ItemRecord.objects.using(bdd).filter(excl =e[0]))
        dict[exclusion] =value
    del dict['']

    #Collections involved in arbitration for claiming 1st rank and number of serials concerned
    c1st, s1st =0,[]
    for i in ItemRecord.objects.using(bdd).filter(rank =1, status =0):
        if len(ItemRecord.objects.using(bdd).filter(rank =1, sid =i.sid)) >1:
            c1st +=1
            if i.sid not in s1st:
                s1st.append(i.sid)
    s1st = len(s1st)

    #Collections involved in arbitration for 1st rank not claimed by any of the libraries
    cnone, snone =0,[]