views.py

epl_version ="v1.20.0 (Wulfégonde)"
date_version ="March 23, 2021"
# Mise au niveau de :
# epl_version ="v1.21-beta.2 (~Berchilde)"
# date_version ="April 16, 2021"

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

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

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)

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


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


def home(request):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

    "Homepage"

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

    #Feature input :
    i = Feature()
    form = FeatureForm(request.POST, instance =i)
    if form.is_valid():
        lid = Library.objects.get(name =i.libname).lid
        feature =i.feaname
        if not Feature.objects.filter(feaname =feature, libname =i.libname):
            i.save()

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

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


def about(request):

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


def contact(request):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr
    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"\
             + ".\n" + "Ne répondez pas au présent message s'il vous plaît" + ".\n" + \
             "Rappel de l'objet de votre message" + " : " + subject2 + \
             "\n" + "Rappel de votre message" + " :\n" + "\n" + \
             _("***** Début *****") + "\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
    webmaster =wbmstr
    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"\
             + ".\n" + "Ne répondez pas au présent message s'il vous plaît" + ".\n" + \
             "Rappel de l'objet de votre message" + " : " + subject2 + \
             "\n" + "Rappel de votre message" + " :\n" + "\n" + \
             _("***** Début *****") + "\n" + body + "\n" + _("*****  Fin  *****")
            dest1 = [wbmstr]
            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 confirm(request):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

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


def router(request, lid):

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

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


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

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


def logout_view(request):

    "Homepage sepcial disconnected"

    logout(request)

    # Redirect to a success page.

    version =epl_version
    webmaster =wbmstr
    project = Project.objects.all().order_by('pk')[0].name

    #Feature input :
    i = Feature()
    form = FeatureForm(request.POST, instance =i)
    if form.is_valid():
        lid = Library.objects.get(name =i.libname).lid
        feature =i.feaname
        # if not Feature.objects.filter(feaname = i.feaname, libname =i.libname):
        i.save()
        if lid =="999999999":
            if feature =='instrtodo':
                return instrtodo(request, lid, 'title')
            else:
                return checkinstr(request)
        else:
            if feature =='ranking':
                return ranktotake(request, lid, 'title')
            elif feature =='arbitration':
                return arbitration(request, lid, 'title')
            elif feature =='instrtodo':
                return instrtodo(request, lid, 'title')
            elif feature =='edition':
                return tobeedited(request, lid, 'title')

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


def notintime(request, sid, lid):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

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


def indicators(request):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

    #Indicators :

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

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

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

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

    #Exclusions details
    dict ={}
    for e in EXCLUSION_CHOICES:
        exclusion =str(e[0])
        value =len(ItemRecord.objects.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.filter(rank =1, status =0):
        if len(ItemRecord.objects.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,[]
    for i in ItemRecord.objects.exclude(rank =0).exclude(rank =1).exclude(rank =99):
        if len(ItemRecord.objects.filter(sid =i.sid, rank =99)) ==0 and \
        len(ItemRecord.objects.filter(sid =i.sid, rank =1)) ==0 and \
        len(ItemRecord.objects.filter(sid =i.sid).exclude(rank =0)) >1:
            cnone +=1
            if i.sid not in snone:
                snone.append(i.sid)
    snone = len(snone)

    #Collections involved in arbitration for any of the two reasons and number of serials concerned
    ctotal = c1st + cnone
    stotal = s1st + snone

    #Number of collections :
    coll = len(ItemRecord.objects.all())

    #Number of potential candidates :
    cand =[]
    for e in ItemRecord.objects.all():
        if len(ItemRecord.objects.filter(sid =e.sid)) >1 and not e.sid in cand:
            cand.append(e.sid)
    cand = len(cand)

    #from which strict duplicates :
    dupl =[]
    for e in ItemRecord.objects.all():
        if len(ItemRecord.objects.filter(sid =e.sid)) ==2 and not e.sid in dupl:
            dupl.append(e.sid)
    dupl = len(dupl)

    #triplets :
    tripl =[]
    for e in ItemRecord.objects.all():
        if len(ItemRecord.objects.filter(sid =e.sid)) ==3 and not e.sid in tripl:
            tripl.append(e.sid)
    tripl = len(tripl)

    #quadruplets :
    qudrpl =[]
    for e in ItemRecord.objects.all():
        if len(ItemRecord.objects.filter(sid =e.sid)) ==4 and not e.sid in qudrpl:
            qudrpl.append(e.sid)
    qudrpl = len(qudrpl)

    #Unicas :
    isol =[]
    for e in ItemRecord.objects.all():
        if len(ItemRecord.objects.filter(sid =e.sid)) ==1 and not e.sid in isol:
            isol.append(e.sid)
    isol = len(isol)

    #candidate collections :
    candcoll =coll - isol

    #Number of descarded ressources for exclusion reason :
    discard =[]
    for i in ItemRecord.objects.filter(rank =0):
        if len(ItemRecord.objects.filter(sid =i.sid).exclude(rank =0)) ==1 and not i.sid in discard:
            discard.append(i.sid)
    discard = len(discard)

    #Number of real candidates (collections)
    realcandcoll =candcoll - (exclus + discard)

    #Number of ressources whose instruction of bound elements may begin :
    bdmaybeg = len(ItemRecord.objects.filter(rank =1, status =1))

    #Number of ressources whose bound elements are currently instructed  :
    bdonway = len(ItemRecord.objects.filter(rank =1, status =2))

    #Number of ressources whose instruction of not bound elements may begin :
    notbdmaybeg = len(ItemRecord.objects.filter(rank =1, status =3))

    #Number of ressources whose not bound elements are currently instructed  :
    notbdonway = len(ItemRecord.objects.filter(rank =1, status =4))

    #Number of ressources completely instructed :
    fullinstr = len(ItemRecord.objects.filter(rank =1, status =5))

    #Number of failing sheets :
    fail = len(ItemRecord.objects.filter(status =6, rank =1))

    #Number of instructions :
    instr = len(Instruction.objects.all())

    #Fiches incomplètement instruites, défectueuses ou dont le traitement peut débuter mais n'a pas débuté
    incomp = bdmaybeg + bdonway + notbdmaybeg + notbdonway + fail

    #Ressources pour lesquelles le positionnement doit être complété (hors arbitrage)
    stocomp =[]
    for i in ItemRecord.objects.filter(rank =99):
        if len(ItemRecord.objects.filter(sid =i.sid).exclude(rank =0)) >1 and not i.sid in stocomp:
            stocomp.append(i.sid)
    stocomp = len(stocomp)

    #Number of real candidates (ressources)
    realcand =stocomp + incomp + fullinstr

    #Absolute achievement :
    absolute_real = round(10000*(fullinstr + discard)/cand)/100

    #Relative achievement :
    relative_real = round(10000*fullinstr/realcand)/100

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


def search(request):
# Lot of code for this view is similar with the code for "current_status" view : When changing here, think to change there

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

    libch = ('checker','checker'),
    for l in Library.objects.all().exclude(name ='checker').order_by('name'):
        libch += (l.name, l.name),

    class SearchForm(forms.Form):
        sid = forms.CharField(required = True, label =_("ppn"))
        lib = forms.ChoiceField(required = True, widget=forms.Select, choices=libch, label =_("Votre bibliothèque"))

    l =0
    form = SearchForm(request.POST or None)
    if form.is_valid():
        sid = form.cleaned_data['sid']
        lib = form.cleaned_data['lib']
        lid = Library.objects.get(name =lib).lid
        n = len(ItemRecord.objects.filter(sid =sid))
        ranklist =[] # if n==0
        progress =0
        action, laction =0,0
        alteraction, lalteraction =0,0

        if ItemRecord.objects.filter(sid =sid):
            # Bibliographic data :
            title = ItemRecord.objects.filter(sid =sid)[0].title
            issn = ItemRecord.objects.filter(sid =sid)[0].issn
            pubhist = ItemRecord.objects.filter(sid =sid)[0].pubhist
        if ItemRecord.objects.filter(sid =sid, lid =lid):
            l =1
            # ItemRecord data :
            holdstat = ItemRecord.objects.get(sid =sid, lid = lid).holdstat
            missing = ItemRecord.objects.get(sid =sid, lid = lid).missing
            cn = ItemRecord.objects.get(sid =sid, lid = lid).cn

        if n ==1:
            bil =Library.objects.get(lid =ItemRecord.objects.get(sid =sid).lid).name

        elif n >1:

            #Calcul de l'avancement:
            higher_status =ItemRecord.objects.filter(sid =sid).order_by("-status")[0].status
            if higher_status ==6:
                if len(Instruction.objects.filter(sid =sid, name ="checker")):
                    progress =_("Anomalie signalée lors de la phase des non reliés")
                else:
                    progress =_("Anomalie signalée lors de la phase des reliés")
            elif higher_status ==5:
                progress =_("Instruction achevée")
                if ItemRecord.objects.filter(sid =sid, lid =lid).exclude(rank =0):
                    action, laction =_("Edition de la fiche de résultante"), "/ed/" + str(sid) + "/" + str(lid)
            elif higher_status ==4:
                if len(ItemRecord.objects.filter(sid =sid, status =4)) ==len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)):
                    progress =_("En attente de validation finale par le contrôleur")
                    if lid =="999999999":
                        action, laction =_("Validation finale"), "/end/" + str(sid) + "/" + str(lid)
                else:
                    if lid !="999999999":
                        if ItemRecord.objects.filter(sid =sid, lid =lid, status =3):
                            if Instruction.objects.filter(sid =sid, bound =" ", name =Library.objects.get(lid =lid).name):
                                progress =_("Instruction des non reliés en cours pour votre collection")
                            else:
                                progress =_("Instruction des non reliés à débuter pour votre collection")
                            action, laction =_("Instruction"), "/add/" + str(sid) + "/" + str(lid)
                        else:
                            xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =3).lid).name
                            if Instruction.objects.filter(sid =sid, bound =" ", name =xname):
                                progress =_("Instruction des non reliés en cours pour : ")
                            else:
                                progress =_("Instruction des non reliés en cours ; à débuter pour : ")
                    else:#lid ="999999999"
                        xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =3).lid).name
                        if Instruction.objects.filter(sid =sid, bound =" ", name =xname):
                            progress =_("Instruction des non reliés en cours pour : ")
                        else:
                            progress =_("Instruction des non reliés en cours ; à débuter pour : ")
            elif higher_status ==3:
                if lid !="999999999":
                    if ItemRecord.objects.filter(sid =sid, lid =lid, status =3):
                        if Instruction.objects.filter(sid =sid, bound =" ", name =Library.objects.get(lid =lid).name):
                            progress =_("Instruction des non reliés en cours pour votre collection")
                        else:
                            progress =_("Instruction des non reliés à débuter pour votre collection")
                        action, laction =_("Instruction"), "/add/" + str(sid) + "/" + str(lid)
                    else:
                        xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =3).lid).name
                        if Instruction.objects.filter(sid =sid, bound =" ", name =xname):
                            progress =_("Instruction des non reliés en cours pour : ")
                        else:
                            progress =_("Instruction des non reliés en cours ; à débuter pour : ")
                else:#lid ="999999999"
                    xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =3).lid).name
                    if Instruction.objects.filter(sid =sid, bound =" ", name =xname):
                        progress =_("Instruction des non reliés en cours pour : ")
                    else:
                        progress =_("Instruction des non reliés en cours ; à débuter pour : ")
            elif higher_status ==2:
                if len(ItemRecord.objects.filter(sid =sid, status =2)) ==len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)):
                    progress =_("En attente de validation intermédiaire par le contrôleur")
                    if lid =="999999999":
                        action, laction =_("Validation intermédiaire"), "/end/" + str(sid) + "/" + str(lid)
                else:
                    if lid !="999999999":
                        if ItemRecord.objects.filter(sid =sid, lid =lid, status =1):
                            if Instruction.objects.filter(sid =sid, bound ="x", name =Library.objects.get(lid =lid).name):
                                progress =_("Instruction des reliés en cours pour votre collection")
                            else:
                                progress =_("Instruction des reliés à débuter pour votre collection")
                            action, laction =_("Instruction"), "/add/" + str(sid) + "/" + str(lid)
                        else:
                            xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =1).lid).name
                            if Instruction.objects.filter(sid =sid, bound ="x", name =xname):
                                progress =_("Instruction des reliés en cours pour : ")
                            else:
                                progress =_("Instruction des reliés en cours ; à débuter pour : ")
                    else:#lid ="999999999"
                        xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =1).lid).name
                        if Instruction.objects.filter(sid =sid, bound ="x", name =xname):
                            progress =_("Instruction des reliés en cours pour : ")
                        else:
                            progress =_("Instruction des reliés en cours ; à débuter pour : ")
            elif higher_status ==1:
                if lid !="999999999":
                    if ItemRecord.objects.filter(sid =sid, lid =lid, status =1):
                        if Instruction.objects.filter(sid =sid, bound ="x", name =Library.objects.get(lid =lid).name):
                            progress =_("Instruction des reliés en cours pour votre collection")
                        else:
                            progress =_("Instruction des reliés à débuter pour votre collection")
                        action, laction =_("Instruction"), "/add/" + str(sid) + "/" + str(lid)
                    else:
                        xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =1).lid).name
                        if Instruction.objects.filter(sid =sid, bound ="x", name =xname):
                            progress =_("Instruction des reliés en cours pour : ")
                        else:
                            progress =_("Instruction des reliés en cours ; à débuter pour : ")
                    if ItemRecord.objects.filter(sid =sid, lid =lid) and len(Instruction.objects.filter(sid =sid)) ==0:
                        alteraction, lalteraction =_("Modification éventuelle du rang de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                else:#lid ="999999999"
                    xname =Library.objects.get(lid =ItemRecord.objects.get(sid =sid, status =1).lid).name
                    if Instruction.objects.filter(sid =sid, bound ="x", name =xname):
                        progress =_("Instruction des reliés en cours pour : ")
                    else:
                        progress =_("Instruction des reliés en cours ; à débuter pour : ")
            else: # higher_status ==0
                if lid !="999999999":
                    if len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)) <2:
                        progress =_("La ressource n'est plus candidate au dédoublonnement")
                        if ItemRecord.objects.filter(sid =sid, lid =lid, rank =0):
                             action, laction =_("Repositionnement éventuel de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                    elif ItemRecord.objects.filter(sid =sid, rank =99) and len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)) >1:
                        if ItemRecord.objects.filter(sid =sid, rank =99, lid =lid):
                            progress =_("Positionnement à compléter pour votre collection")
                            action, laction =_("Positionnement de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                        else:
                            progress =_("Positionnement à compléter pour une ou plusieurs collections")
                            if ItemRecord.objects.filter(sid =sid, lid =lid):
                                alteraction, lalteraction =_("Modification éventuelle du rang de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                    elif len(ItemRecord.objects.filter(sid =sid, rank =1)) >1:
                        if ItemRecord.objects.filter(sid =sid, rank =1, lid =lid):
                            progress =_("Rang 1 revendiqué pour plusieurs collections dont la vôtre")
                            action, laction =_("Repositionnement éventuel de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                        else:
                            progress =_("Rang 1 revendiqué pour plusieurs collections mais pas la vôtre")
                            if ItemRecord.objects.filter(sid =sid, lid =lid):
                                alteraction, lalteraction =_("Modification éventuelle du rang de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                    else:# len(ItemRecord.objects.filter(sid =sid, rank =1)) ==0:
                        progress =_("Le rang 1 n'a été revendiqué pour aucune collection")
                        if ItemRecord.objects.filter(sid =sid, lid =lid):
                            action, laction =_("Repositionnement éventuel de votre collection"), "/rk/" + str(sid) + "/" + str(lid)
                else: #lid ="999999999"
                    if len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)) <2:
                        progress =_("La ressource n'est plus candidate au dédoublonnement")
                    elif ItemRecord.objects.filter(sid =sid, rank =99) and len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)) >1:
                        progress =_("Positionnement à compléter pour une ou plusieurs collections")
                    elif len(ItemRecord.objects.filter(sid =sid, rank =1)) >1:
                        progress =_("Rang 1 revendiqué pour plusieurs collections")
                    else:# len(ItemRecord.objects.filter(sid =sid, rank =1)) ==0:
                        progress =_("Le rang 1 n'a été revendiqué pour aucune collection")

            #Getting instructions for the considered ressource :
            instrlist = Instruction.objects.filter(sid = sid).order_by('line')
            size =len(instrlist)

            try:
                pklastone = Instruction.objects.filter(sid = sid).latest('pk').pk
            except:
                pklastone =0

            #Attachements :
            attchmt =ItemRecord.objects.filter(sid =sid).order_by('-status')
            attlist = [(Library.objects.get(lid =element.lid).name, element) for element in attchmt]

            rklist = ItemRecord.objects.filter(sid =sid).order_by('rank', 'lid')
            ranklist = [(element, Library.objects.get(lid =element.lid).name) for element in rklist]

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

@login_required
def reinit(request, sid):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr
    info =""

    ressource =ItemRecord.objects.get(sid =sid, rank =1)

    umail, uname = request.user.email, request.user.username

    flag =0

    for u in BddAdmin.objects.all():
        if (u.contact, u.name) ==(umail, uname):
            flag =1

    if flag ==1:
        y = Flag()
        form = CheckForm(request.POST or None, instance =y)

        if form.is_valid():
            if y.flag:
                if Instruction.objects.filter(sid =sid, bound =" "):
                    for instr in Instruction.objects.filter(sid =sid).exclude(bound ="x"):
                        instr.delete()
                    for item in ItemRecord.objects.filter(sid =sid):
                        if item.rank ==1:
                            item.status =3
                            item.save()
                        else:
                            item.status =2
                            item.save()
                else:
                    for instr in Instruction.objects.filter(sid =sid):
                        instr.delete()
                    for item in ItemRecord.objects.filter(sid =sid):
                        if item.rank ==1:
                            item.status =1
                            item.save()
                        else:
                            item.status =0
                            item.save()

                #Message data :
                nextlid =ItemRecord.objects.get(sid =sid, rank =1).lid
                nextlib =Library.objects.get(lid =nextlid)
                subject = "eplouribousse : " + str(sid) + " / " + str(nextlid)
                host = str(request.get_host())
                message = _("Votre tour est venu d'instruire la fiche eplouribousse pour le ppn ") + str(sid) + \
                " :\n" + "https://" + host + "/add/" + str(sid) + '/' + str(nextlid) + \
                " :\n" + _("(Ce message fait suite à une correction apportée par l'administrateur de la base de données)")
                dest = [nextlib.contact]
                if nextlib.contact_bis:
                    dest.append(nextlib.contact_bis)
                if nextlib.contact_ter:
                    dest.append(nextlib.contact_ter)
                send_mail(subject, message, replymail, dest, fail_silently=True, )

                return current_status(request, sid, "999999999")
            else:
                info =_("Vous n'avez pas coché !")

    else:
        return notintime(request, sid, lid)

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


@login_required
def takerank(request, sid, lid):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

    #Authentication control :
    if not request.user.email in [Library.objects.get(lid =lid).contact, Library.objects.get(lid =lid).contact_bis, Library.objects.get(lid =lid).contact_ter]:
        return home(request)

    #Control (takerank only if still possible ; status still ==0 for all attached libraries ;
    #or status ==1 but no instruction yet ; lid not "999999999")

    if len(list(ItemRecord.objects.filter(sid =sid).exclude(status =0).exclude(status =1))):
        return notintime(request, sid, lid)
    elif len(list(ItemRecord.objects.filter(sid =sid, status =1))) and len(list(Instruction.objects.filter(sid = sid))):
        return notintime(request, sid, lid)
    elif lid =="999999999":
        return notintime(request, sid, lid)

    # For position form :
    i = ItemRecord.objects.get(sid = sid, lid = lid)
    f = PositionForm(request.POST, instance=i)
    if f.is_valid():
        #last controls before modifications :
        if (len(list(ItemRecord.objects.filter(sid = sid, status =1))) and not len(list(Instruction.objects.filter(sid = sid)))) or\
        len(list(ItemRecord.objects.filter(sid = sid).exclude(status =0))) ==0:
            global lastrked
            lastrked =i
            # if len(ItemRecord.objects.filter(sid =sid).exclude(status =0)) ==0:
            if i.excl !='':
                i.rank =0
            f.save()
            # Other status modification if all libraries have taken rank :
            # Status = 1 : item whose lid identified library must begin bound elements instructions on the sid identified serial (rank =1, no arbitration)
            # ordering by pk for identical ranks upper than 1.

            if len(ItemRecord.objects.filter(sid =sid, status =1)): #Since it's possible when modifying
                for elmt in ItemRecord.objects.filter(sid =sid).exclude(rank =99):
                    if elmt.status !=0:
                        elmt.status =0
                        elmt.save()

            if len(ItemRecord.objects.filter(sid =sid, rank =99)) ==0 and len(ItemRecord.objects.filter(sid =sid, rank =1)) ==1 \
            and len(ItemRecord.objects.filter(sid =sid).exclude(rank =0)) >1:
                p = ItemRecord.objects.filter(sid =sid).exclude(rank =0).exclude(rank =99).order_by("rank", "pk")[0]
                p.status =1
                p.save()

        else:
            return notintime(request, sid, lid)

        return router(request, lid)

    # Item records list :
    itlist = ItemRecord.objects.filter(sid =  sid)
    itemlist = [(element, Library.objects.get(lid =element.lid).name) for element in itlist]
    # itemlist = list(itemlist)

    # restricted Item records list (without excluded collections) :
    r_itemlist = ItemRecord.objects.filter(sid =  sid).exclude(rank =0)
    r_itemlist = list(r_itemlist)

    # Ressource data :
    ress = itemlist[0][0]

    # Library data :
    lib = Library.objects.get(lid = lid)

    periscope = "https://periscope.sudoc.fr/?ppnviewed=" + str(sid) + "&orderby=SORT_BY_PCP&collectionStatus=&tree="
    for i in r_itemlist[:-1]:
        periscope = periscope + i.lid + "%2C"
    periscope = periscope + r_itemlist[-1].lid

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


@login_required
def addinstr(request, sid, lid):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr
    length =0

    q = "x"
    if len(list((Instruction.objects.filter(sid =sid)).filter(name ='checker'))):
        q =" "
    else:
        q ="x"

    #Authentication control :
    if not request.user.email in [Library.objects.get(lid =lid).contact, Library.objects.get(lid =lid).contact_bis, Library.objects.get(lid =lid).contact_ter]:
        return home(request)

    do = notintime(request, sid, lid)

    #Control (addinstr only if it's up to the considered lid)
    try:
        if lid !="999999999":
            if ItemRecord.objects.get(sid =sid, lid =lid).status not in [1, 3]:
                return do

        else: # i.e. lid =="999999999"
            if len(list((Instruction.objects.filter(sid =sid)).filter(name ='checker'))) ==2:
                return do
            elif len(list((Instruction.objects.filter(sid =sid)).filter(name ='checker'))) ==1:
                if len(list(ItemRecord.objects.filter(sid =sid).exclude(rank =0))) != len(list(ItemRecord.objects.filter(sid =sid, status =4))):
                    return do
            else: # i.e. len(list((Instruction.objects.filter(sid =sid)).filter(name ='checker'))) ==0
                if len(list(ItemRecord.objects.filter(sid =sid).exclude(rank =0))) != len(list(ItemRecord.objects.filter(sid =sid, status =2))):
                    return do
    except:
        z =1 #This is just to continue


    #Ressource data :
    itemlist = ItemRecord.objects.filter(sid = sid).exclude(rank =0).order_by("rank", 'pk')
    ress = itemlist[0]

    #Library data :
    lib = Library.objects.get(lid = lid)

    # Library list ordered by 'rank' (except "checker" which must be the last one)
    # to get from the precedent item list above :
    liblist = []
    for e in itemlist:
        liblist.append(Library.objects.get(lid = e.lid))
    liblist.append(Library.objects.get(name = 'checker'))

    #Remedied library list :
    remliblist = []
    for e in itemlist:
        remliblist.append(Library.objects.get(lid = e.lid))
    if (Library.objects.get(lid =lid)).name != 'checker':
        remliblist.remove(Library.objects.get(name = lib.name))

    #Info :
    info =""

    #Stage (bound or not bound) :
    if len(list((Instruction.objects.filter(sid =sid)).filter(name ='checker'))) ==0:
        bd =_('éléments reliés')
    elif len(list((Instruction.objects.filter(sid =sid)).filter(name ='checker'))) ==1:
        bd =_('éléments non reliés')

    if lid =="999999999":
        do = endinstr(request, sid, lid)
        return do

    else:
        #Instruction form instanciation and validation :
        i = Instruction(sid = sid, name = lib.name)
        f = InstructionForm(request.POST, instance =i)

        REM_CHOICES =('',''),
        bibliolist =[]
        if Instruction.objects.filter(sid =sid).exclude(name =Library.objects.get(lid =lid).name).exclude(name ='checker'):
            for e in Instruction.objects.filter(sid =sid).exclude(name =Library.objects.get(lid =lid).name).exclude(name ='checker'):
                if (e.exc or e.degr) and Library.objects.get(name =e.name).name not in bibliolist:
                    bibliolist.append(Library.objects.get(name =e.name).name)
            bibliolist.sort()
            length =len(bibliolist)
        if length:
            for l in bibliolist:
                REM_CHOICES += (l, l),

        class Instr_Form(forms.Form):
            oname = forms.ChoiceField(required = False, widget=forms.Select(attrs={'title': _("Intitulé de la bibliothèque ayant précédemment déclaré une 'exception' ou un 'améliorable'")}), choices=REM_CHOICES, label =_("Bibliothèque remédiée"),)

        foname = Instr_Form(request.POST or None)

        if f.is_valid():
            if foname.is_valid():
                i.oname = foname.cleaned_data['oname']
            i.bound =q
            #A line may only be registered once :
            if not len(Instruction.objects.filter(sid =sid, name =lib.name, bound =i.bound, oname =i.oname, descr =i.descr, exc =i.exc, degr =i.degr)):
                i.line +=1
                i.time =Now()
                f.save()
                url ="/add/" + str(sid) + "/" + str(lid)
                return HttpResponseRedirect(url)
            else:
                info = _("Vous ne pouvez pas valider deux fois la même ligne d'instruction.")

        #Renumbering instruction lines :
        try:
            instr = Instruction.objects.filter(sid = sid).order_by('line', '-pk')
            j, l =0, 1
            while j <= len(instr):
                instr[j].line = l
                instr[j].save()
                j +=1
                l +=1
        except:
            pass
        instrlist = Instruction.objects.filter(sid = sid).order_by('line')

        try:
            pklastone = Instruction.objects.filter(sid = sid).latest('pk').pk
        except:
            pklastone =0

    try:
        itrec =ItemRecord.objects.get(sid =sid, lid =lid)
    except:
        itrec =""

    return render(request, 'epl/addinstruction.html', { 'ressource' : ress, \
    'library' : lib, 'instructions' : instrlist , 'form' : f, 'foname' : foname, 'librarylist' : \
    liblist, 'remedied_lib_list' : remliblist, 'sid' : sid, 'stage' : bd, 'info' : info, \
    'lid' : lid, 'expected' : q, 'lastone' : pklastone, 'k' : k, 'version' : version, 'l' : length, 'itrec' : itrec, 'webmaster' : webmaster, })

@login_required
def selinstr(request, sid, lid):

    k = logstatus(request)
    version =epl_version
    webmaster =wbmstr

    #Authentication control :
    if not request.user.email in [Library.objects.get(lid =lid).contact, Library.objects.get(lid =lid).contact_bis, Library.objects.get(lid =lid).contact_ter]:
        return home(request)

    do = notintime(request, sid, lid)

    #Control (selinstr only if it's up to the considered library == same conditions as for addinstr if lid not "999999999")
    try:
        if lid !="999999999":
            if ItemRecord.objects.get(sid = sid, lid =lid).status not in [1, 3]:
                return do

        else: # i.e. lid =="999999999"
            return do

    except:
        z =1 #This is just to continue

    #Ressource data :
    itemlist = ItemRecord.objects.filter(sid = sid).exclude(rank =0).order_by("rank", 'pk')
    ress = itemlist[0]

    #Library data :
    lib = Library.objects.get(lid = lid)

    # Library list ordered by 'rank' (except "checker" which must be the last one)
    # to get from the precedent item list above :
    liblist = []
    for e in itemlist:
        liblist.append(Library.objects.get(lid = e.lid))
    liblist.append(Library.objects.get(name = 'checker'))

    #Remedied library list :
    remliblist = []
    for e in itemlist: