ScoDoc-PE/app/scodoc/sco_groups_view.py

# -*- mode: python -*-
# -*- coding: utf-8 -*-

##############################################################################
#
# Gestion scolarite IUT
#
# Copyright (c) 1999 - 2021 Emmanuel Viennet.  All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#   Emmanuel Viennet      emmanuel.viennet@viennet.net
#
##############################################################################

"""Affichage étudiants d'un ou plusieurs groupes
   sous forme: de liste html (table exportable), de trombinoscope (exportable en pdf)
"""

# Re-ecriture en 2014 (re-organisation de l'interface, modernisation du code)

import collections
import datetime
import operator
import urllib
from urllib.parse import parse_qs
import time


from flask import url_for, g, request

import app.scodoc.sco_utils as scu
from app.scodoc import html_sco_header
from app.scodoc import sco_abs
from app.scodoc import sco_excel
from app.scodoc import sco_formsemestre
from app.scodoc import sco_groups
from app.scodoc import sco_moduleimpl
from app.scodoc import sco_parcours_dut
from app.scodoc import sco_portal_apogee
from app.scodoc import sco_preferences
from app.scodoc import sco_etud
from app.scodoc.gen_tables import GenTable
from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc.sco_permissions import Permission
from six.moves import range

JAVASCRIPTS = html_sco_header.BOOTSTRAP_MULTISELECT_JS + [
    "js/etud_info.js",
    "js/groups_view.js",
]

CSSSTYLES = html_sco_header.BOOTSTRAP_MULTISELECT_CSS


def groups_view(
    group_ids=[],
    format="html",
    REQUEST=None,
    # Options pour listes:
    with_codes=0,
    etat=None,
    with_paiement=0,  # si vrai, ajoute colonnes infos paiement droits et finalisation inscription (lent car interrogation portail)
    with_archives=0,  # ajoute colonne avec noms fichiers archivés
    with_annotations=0,
    formsemestre_id=None,  # utilise si aucun groupe selectionné
):
    """Affichage des étudiants des groupes indiqués
    group_ids: liste de group_id
    format: csv, json, xml, xls, allxls, xlsappel, moodlecsv, pdf
    """
    # Informations sur les groupes à afficher:
    groups_infos = DisplayedGroupsInfos(
        group_ids,
        formsemestre_id=formsemestre_id,
        etat=etat,
        select_all_when_unspecified=True,
    )
    # Formats spéciaux: download direct
    if format != "html":
        return groups_table(
            groups_infos=groups_infos,
            format=format,
            REQUEST=REQUEST,
            with_codes=with_codes,
            etat=etat,
            with_paiement=with_paiement,
            with_archives=with_archives,
            with_annotations=with_annotations,
        )

    H = [
        html_sco_header.sco_header(
            javascripts=JAVASCRIPTS,
            cssstyles=CSSSTYLES,
            init_qtip=True,
        )
    ]
    # Menu choix groupe
    H.append("""<div id="group-tabs">""")
    H.append(form_groups_choice(groups_infos, submit_on_change=True))
    # Note: le formulaire est soumis a chaque modif des groupes
    # on pourrait faire comme pour le form de saisie des notes. Il faudrait pour cela:
    #  - charger tous les etudiants au debut, quels que soient les groupes selectionnés
    #  - ajouter du JS pour modifier les liens (arguments group_ids) quand le menu change

    # Tabs
    # H.extend( ("""<span>toto</span><ul id="toto"><li>item 1</li><li>item 2</li></ul>""",) )
    H.extend(
        (
            """<ul class="nav nav-tabs">
    <li class="active"><a href="#tab-listes" data-toggle="tab">Listes</a></li>
    <li><a href="#tab-photos" data-toggle="tab">Photos</a></li>
    <li><a href="#tab-abs" data-toggle="tab">Absences et feuilles...</a></li>
    </ul>
    </div>
    <!-- Tab panes -->
    <div class="tab-content">
    <div class="tab-pane active" id="tab-listes">
    """,
            groups_table(
                groups_infos=groups_infos,
                format=format,
                REQUEST=REQUEST,
                with_codes=with_codes,
                etat=etat,
                with_paiement=with_paiement,
                with_archives=with_archives,
                with_annotations=with_annotations,
            ),
            "</div>",
            """<div class="tab-pane" id="tab-photos">""",
            tab_photos_html(groups_infos, etat=etat, REQUEST=REQUEST),
            #'<p>hello</p>',
            "</div>",
            '<div class="tab-pane" id="tab-abs">',
            tab_absences_html(groups_infos, etat=etat, REQUEST=REQUEST),
            "</div>",
        )
    )

    H.append(html_sco_header.sco_footer())
    return "\n".join(H)


def form_groups_choice(groups_infos, with_selectall_butt=False, submit_on_change=False):
    """form pour selection groupes
    group_ids est la liste des groupes actuellement sélectionnés
    et doit comporter au moins un élément, sauf si formsemestre_id est spécifié.
    (utilisé pour retrouver le semestre et proposer la liste des autres groupes)

    Si submit_on_change, ajoute une classe "submit_on_change" qui est utilisee en JS
    """
    default_group_id = sco_groups.get_default_group(groups_infos.formsemestre_id)

    H = [
        """<form id="group_selector" method="get">
    <input type="hidden" name="formsemestre_id" id="formsemestre_id" value="%s"/>
    <input type="hidden" name="default_group_id" id="default_group_id" value="%s"/>
    Groupes: 
    """
        % (groups_infos.formsemestre_id, default_group_id)
    ]

    H.append(menu_groups_choice(groups_infos, submit_on_change=submit_on_change))

    if with_selectall_butt:
        H.append(
            """<input type="button" value="sélectionner tous" onmousedown="select_tous();"/>"""
        )
    H.append("</form>")

    return "\n".join(H)


def menu_groups_choice(groups_infos, submit_on_change=False):
    """menu pour selection groupes
    group_ids est la liste des groupes actuellement sélectionnés
    et doit comporter au moins un élément, sauf si formsemestre_id est spécifié.
    (utilisé pour retrouver le semestre et proposer la liste des autres groupes)
    """
    default_group_id = sco_groups.get_default_group(groups_infos.formsemestre_id)

    if submit_on_change:
        klass = "submit_on_change"
    else:
        klass = ""
    H = [
        """<select name="group_ids" id="group_ids_sel" class="multiselect %s" multiple="multiple">
    """
        % (klass,)
    ]

    n_members = len(sco_groups.get_group_members(default_group_id))
    if default_group_id in groups_infos.group_ids:
        selected = "selected"
    else:
        selected = ""
    H.append(
        '<option class="default_group" value="%s" %s>%s (%s)</option>'
        % (default_group_id, selected, "Tous", n_members)
    )

    for partition in groups_infos.partitions:
        H.append('<optgroup label="%s">' % partition["partition_name"])
        # Les groupes dans cette partition:
        for g in sco_groups.get_partition_groups(partition):
            if g["group_id"] in groups_infos.group_ids:
                selected = "selected"
            else:
                selected = ""
            if g["group_name"]:
                n_members = len(sco_groups.get_group_members(g["group_id"]))
                H.append(
                    '<option value="%s" %s>%s (%s)</option>'
                    % (g["group_id"], selected, g["group_name"], n_members)
                )
        H.append("</optgroup>")
    H.append("</select> ")
    return "\n".join(H)


def menu_group_choice(group_id=None, formsemestre_id=None):
    """Un bête menu pour choisir un seul groupe
    group_id est le groupe actuellement sélectionné.
    Si aucun groupe selectionné, utilise formsemestre_id pour lister les groupes.
    """
    if group_id:
        group = sco_groups.get_group(group_id)
        formsemestre_id = group["formsemestre_id"]
    elif not formsemestre_id:
        raise ValueError("missing formsemestre_id")
    H = [
        """
    <select id="group_selector_u" name="group_id" onchange="reload_selected_group();">
    """
    ]
    if not group_id:
        H.append('<option value="">choisir...</option>')
    for partition in sco_groups.get_partitions_list(formsemestre_id):
        if partition["partition_name"]:
            H.append('<optgroup label="%s">' % partition["partition_name"])
        groups = sco_groups.get_partition_groups(partition)
        for group in groups:
            if group["group_id"] == group_id:
                selected = "selected"
            else:
                selected = ""
            name = group["group_name"] or "Tous"
            n_members = len(sco_groups.get_group_members(group["group_id"]))
            H.append(
                '<option value="%s" %s>%s (%s)</option>'
                % (group["group_id"], selected, name, n_members)
            )
        if partition["partition_name"]:
            H.append("</optgroup>")
    H.append(
        """</select>
    <script>
function reload_selected_group() {
var url = $.url();
var group_id = $("#group_selector_u").val();
if (group_id) {
  url.param()['group_id'] = group_id;
  var query_string = $.param(url.param(), traditional=true );
  window.location = url.attr('base') + url.attr('path') + '?' + query_string;
}
}
    </script>
    """
    )
    return "\n".join(H)


class DisplayedGroupsInfos(object):
    """Container with attributes describing groups to display in the page
    .groups_query_args : 'group_ids=xxx&group_ids=yyy'
    .base_url : url de la requete, avec les groupes, sans les autres paramètres
    .formsemestre_id : semestre "principal" (en fait celui du 1er groupe de la liste)
    .members
    .groups_titles
    """

    def __init__(
        self,
        group_ids=[],  # groupes specifies dans l'URL, ou un seul int
        formsemestre_id=None,
        etat=None,
        select_all_when_unspecified=False,
        moduleimpl_id=None,  # used to find formsemestre when unspecified
    ):
        if isinstance(group_ids, int):
            if group_ids:
                group_ids = [group_ids]  # cas ou un seul parametre, pas de liste
            else:
                group_ids = []
        if not formsemestre_id and moduleimpl_id:
            mods = sco_moduleimpl.do_moduleimpl_list(moduleimpl_id=moduleimpl_id)
            if len(mods) != 1:
                raise ValueError("invalid moduleimpl_id")
            formsemestre_id = mods[0]["formsemestre_id"]

        if not group_ids:  # appel sans groupe (eg page accueil)
            if not formsemestre_id:
                raise Exception("missing parameter formsemestre_id or group_ids")
            if select_all_when_unspecified:
                group_ids = [sco_groups.get_default_group(formsemestre_id)]
            else:
                # selectionne le premier groupe trouvé, s'il y en a un
                partition = sco_groups.get_partitions_list(
                    formsemestre_id, with_default=True
                )[0]
                groups = sco_groups.get_partition_groups(partition)
                if groups:
                    group_ids = [groups[0]["group_id"]]
                else:
                    group_ids = [sco_groups.get_default_group(formsemestre_id)]

        gq = []
        for group_id in group_ids:
            gq.append("group_ids=" + str(group_id))
        self.groups_query_args = "&".join(gq)
        self.base_url = request.base_url + "?" + self.groups_query_args
        self.group_ids = group_ids
        self.groups = []
        groups_titles = []
        self.members = []
        self.tous_les_etuds_du_sem = (
            False  # affiche tous les etuds du semestre ? (si un seul semestre)
        )
        self.sems = collections.OrderedDict()  # formsemestre_id : sem
        self.formsemestre = None
        self.formsemestre_id = formsemestre_id
        self.nbdem = 0  # nombre d'étudiants démissionnaires en tout
        sem = None
        selected_partitions = set()
        for group_id in group_ids:
            group_members, group, group_tit, sem, nbdem = sco_groups.get_group_infos(
                group_id, etat=etat
            )
            self.groups.append(group)
            self.nbdem += nbdem
            self.sems[sem["formsemestre_id"]] = sem
            if not self.formsemestre_id:
                self.formsemestre_id = sem["formsemestre_id"]
                self.formsemestre = sem
            self.members.extend(group_members)
            groups_titles.append(group_tit)
            if group["group_name"] == None:
                self.tous_les_etuds_du_sem = True
            else:
                # liste les partitions explicitement sélectionnés (= des groupes de group_ids)
                selected_partitions.add((group["numero"], group["partition_id"]))

        self.selected_partitions = [
            x[1] for x in sorted(list(selected_partitions))
        ]  # -> [ partition_id ]

        if not self.formsemestre:  # aucun groupe selectionne
            self.formsemestre = sco_formsemestre.get_formsemestre(formsemestre_id)

        self.sortuniq()

        if len(self.sems) > 1:
            self.tous_les_etuds_du_sem = False  # plusieurs semestres
        if self.tous_les_etuds_du_sem:
            if sem and sem["semestre_id"] >= 0:
                self.groups_titles = "S%d" % sem["semestre_id"]
            else:
                self.groups_titles = "tous"
            self.groups_filename = self.groups_titles
        else:
            self.groups_titles = ", ".join(groups_titles)
            self.groups_filename = "_".join(groups_titles).replace(" ", "_")
            # Sanitize filename:
            self.groups_filename = scu.make_filename(self.groups_filename)

        # colonnes pour affichages nom des groupes:
        # gère le cas où les étudiants appartiennent à des semestres différents
        self.partitions = []  # les partitions, sans celle par defaut
        for formsemestre_id in self.sems:
            for partition in sco_groups.get_partitions_list(formsemestre_id):
                if partition["partition_name"]:
                    self.partitions.append(partition)

    def sortuniq(self):
        "Trie les étudiants (de plusieurs groupes) et elimine les doublons"
        if (len(self.group_ids) <= 1) or len(self.members) <= 1:
            return  # on suppose que les etudiants d'un groupe sont deja triés
        self.members.sort(
            key=operator.itemgetter("nom_disp", "prenom")
        )  # tri selon nom_usuel ou nom
        to_remove = []
        T = self.members
        for i in range(len(T) - 1, 0, -1):
            if T[i - 1]["etudid"] == T[i]["etudid"]:
                to_remove.append(i)
        for i in to_remove:
            del T[i]

    def get_form_elem(self):
        """html hidden input with groups"""
        H = []
        for group_id in self.group_ids:
            H.append('<input type="hidden" name="group_ids" value="%s"/>' % group_id)
        return "\n".join(H)


# Ancien ZScolar.group_list renommé ici en group_table
def groups_table(
    REQUEST=None,
    groups_infos=None,  # instance of DisplayedGroupsInfos
    with_codes=0,
    etat=None,
    format="html",
    with_paiement=0,  # si vrai, ajoute colonnes infos paiement droits et finalisation inscription (lent car interrogation portail)
    with_archives=0,  # ajoute colonne avec noms fichiers archivés
    with_annotations=0,
):
    """liste etudiants inscrits dans ce semestre
    format: csv, json, xml, xls, allxls, xlsappel, moodlecsv, pdf
    Si with_codes, ajoute 4 colonnes avec les codes etudid, NIP, INE et etape
    """
    from app.scodoc import sco_report

    # log(
    #     "enter groups_table %s: %s"
    #     % (groups_infos.members[0]["nom"], groups_infos.members[0].get("etape", "-"))
    # )
    with_codes = int(with_codes)
    with_paiement = int(with_paiement)
    with_archives = int(with_archives)
    with_annotations = int(with_annotations)

    base_url_np = groups_infos.base_url + "&with_codes=%s" % with_codes
    base_url = (
        base_url_np
        + "&with_paiement=%s&with_archives=%s&with_annotations=%s"
        % (with_paiement, with_archives, with_annotations)
    )
    #
    columns_ids = ["civilite_str", "nom_disp", "prenom"]  # colonnes a inclure
    titles = {
        "civilite_str": "Civ.",
        "nom_disp": "Nom",
        "prenom": "Prénom",
        "email": "Mail",
        "emailperso": "Personnel",
        "etat": "Etat",
        "etudid": "etudid",
        "code_nip": "code_nip",
        "code_ine": "code_ine",
        "datefinalisationinscription_str": "Finalisation inscr.",
        "paiementinscription_str": "Paiement",
        "etudarchive": "Fichiers",
        "annotations_str": "Annotations",
        "etape": "Etape",
        "semestre_groupe": "Semestre-Groupe",  # pour Moodle
    }

    # ajoute colonnes pour groupes
    columns_ids.extend([p["partition_id"] for p in groups_infos.partitions])
    titles.update(
        dict(
            [(p["partition_id"], p["partition_name"]) for p in groups_infos.partitions]
        )
    )
    partitions_name = {
        p["partition_id"]: p["partition_name"] for p in groups_infos.partitions
    }

    if format != "html":  # ne mentionne l'état que en Excel (style en html)
        columns_ids.append("etat")
    columns_ids.append("email")
    columns_ids.append("emailperso")

    if format == "moodlecsv":
        columns_ids = ["email", "semestre_groupe"]

    if with_codes:
        columns_ids += ["etape", "etudid", "code_nip", "code_ine"]
    if with_paiement:
        columns_ids += ["datefinalisationinscription_str", "paiementinscription_str"]
    if with_paiement or with_codes:
        sco_portal_apogee.check_paiement_etuds(groups_infos.members)
    if with_archives:
        from app.scodoc import sco_archives_etud

        sco_archives_etud.add_archives_info_to_etud_list(groups_infos.members)
        columns_ids += ["etudarchive"]
    if with_annotations:
        sco_etud.add_annotations_to_etud_list(groups_infos.members)
        columns_ids += ["annotations_str"]
    moodle_sem_name = groups_infos.formsemestre["session_id"]
    moodle_groupenames = set()
    # ajoute liens
    for etud in groups_infos.members:
        if etud["email"]:
            etud["_email_target"] = "mailto:" + etud["email"]
        else:
            etud["_email_target"] = ""
        if etud["emailperso"]:
            etud["_emailperso_target"] = "mailto:" + etud["emailperso"]
        else:
            etud["_emailperso_target"] = ""
        fiche_url = url_for(
            "scolar.ficheEtud", scodoc_dept=g.scodoc_dept, etudid=etud["etudid"]
        )
        etud["_nom_disp_target"] = fiche_url
        etud["_prenom_target"] = fiche_url

        etud["_nom_disp_td_attrs"] = 'id="%s" class="etudinfo"' % (etud["etudid"])

        if etud["etat"] == "D":
            etud["_css_row_class"] = "etuddem"
        # et groupes:
        for partition_id in etud["partitions"]:
            etud[partition_id] = etud["partitions"][partition_id]["group_name"]
        # Ajoute colonne pour moodle: semestre_groupe, de la forme RT-DUT-FI-S3-2021-PARTITION-GROUPE
        moodle_groupename = []
        if groups_infos.selected_partitions:
            # il y a des groupes selectionnes, utilise leurs partitions
            for partition_id in groups_infos.selected_partitions:
                if partition_id in etud["partitions"]:
                    moodle_groupename.append(
                        partitions_name[partition_id]
                        + "-"
                        + etud["partitions"][partition_id]["group_name"]
                    )
        else:
            # pas de groupes sélectionnés: prend le premier s'il y en a un
            moodle_groupename = ["tous"]
            if etud["partitions"]:
                for p in etud["partitions"].items():  # partitions is an OrderedDict
                    moodle_groupename = [
                        partitions_name[p[0]] + "-" + p[1]["group_name"]
                    ]
                    break

        moodle_groupenames |= set(moodle_groupename)
        etud["semestre_groupe"] = moodle_sem_name + "-" + "+".join(moodle_groupename)

    if groups_infos.nbdem > 1:
        s = "s"
    else:
        s = ""

    if format == "moodlecsv":
        # de la forme S1-[FI][FA]-groupe.csv
        if not moodle_groupenames:
            moodle_groupenames = {"tous"}
        filename = (
            moodle_sem_name
            + "-"
            + groups_infos.formsemestre["modalite"]
            + "-"
            + "+".join(sorted(moodle_groupenames))
        )
    else:
        filename = "etudiants_%s" % groups_infos.groups_filename

    prefs = sco_preferences.SemPreferences(groups_infos.formsemestre_id)
    tab = GenTable(
        rows=groups_infos.members,
        columns_ids=columns_ids,
        titles=titles,
        caption="soit %d étudiants inscrits et %d démissionaire%s."
        % (len(groups_infos.members) - groups_infos.nbdem, groups_infos.nbdem, s),
        base_url=base_url,
        filename=filename,
        pdf_link=False,  # pas d'export pdf
        html_sortable=True,
        html_class="table_leftalign table_listegroupe",
        xml_outer_tag="group_list",
        xml_row_tag="etud",
        text_fields_separator=prefs["moodle_csv_separator"],
        text_with_titles=prefs["moodle_csv_with_headerline"],
        preferences=prefs,
    )
    #
    if format == "html":
        amail_inst = [
            x["email"] for x in groups_infos.members if x["email"] and x["etat"] != "D"
        ]
        amail_perso = [
            x["emailperso"]
            for x in groups_infos.members
            if x["emailperso"] and x["etat"] != "D"
        ]

        if len(groups_infos.members):
            if groups_infos.tous_les_etuds_du_sem:
                htitle = "Les %d étudiants inscrits" % len(groups_infos.members)
            else:
                htitle = "Groupe %s (%d étudiants)" % (
                    groups_infos.groups_titles,
                    len(groups_infos.members),
                )
        else:
            htitle = "Aucun étudiant !"
        H = [
            '<div class="tab-content"><form>' '<h3 class="formsemestre"><span>',
            htitle,
            "</span>",
        ]
        if groups_infos.members:
            Of = []
            options = {
                "with_paiement": "Paiement inscription",
                "with_archives": "Fichiers archivés",
                "with_annotations": "Annotations",
                "with_codes": "Codes",
            }
            for option in options:
                if locals().get(option, False):
                    selected = "selected"
                else:
                    selected = ""
                Of.append(
                    """<option value="%s" %s>%s</option>"""
                    % (option, selected, options[option])
                )

            H.extend(
                [
                    """<span style="margin-left: 2em;"><select name="group_list_options" id="group_list_options" class="multiselect" multiple="multiple">""",
                    "\n".join(Of),
                    """
            </select></span>
            <script type="text/javascript">
  $(document).ready(function() {
  $('#group_list_options').multiselect(
  {
    includeSelectAllOption: false,
    nonSelectedText:'Options...',
    onChange: function(element, checked){
        change_list_options();
    }
    }
  );
  });
  </script>
                """,
                ]
            )
        H.append("</h3></form>")
        if groups_infos.members:
            H.extend(
                [
                    tab.html(),
                    "<ul>",
                    '<li><a class="stdlink" href="%s&format=xlsappel">Feuille d\'appel Excel</a></li>'
                    % (tab.base_url,),
                    '<li><a class="stdlink" href="%s&format=xls">Table Excel</a></li>'
                    % (tab.base_url,),
                    '<li><a class="stdlink" href="%s&format=moodlecsv">Fichier CSV pour Moodle (groupe sélectionné)</a></li>'
                    % (tab.base_url,),
                    """<li>
                    <a class="stdlink" href="export_groups_as_moodle_csv?formsemestre_id=%s">Fichier CSV pour Moodle (tous les groupes)</a>
                    <em>(voir le paramétrage pour modifier le format des fichiers Moodle exportés)</em> 
                    </li>"""
                    % groups_infos.formsemestre_id,
                ]
            )
            if amail_inst:
                H.append(
                    '<li><a class="stdlink" href="mailto:?bcc=%s">Envoyer un mail collectif au groupe de %s (via %d adresses institutionnelles)</a></li>'
                    % (
                        ",".join(amail_inst),
                        groups_infos.groups_titles,
                        len(amail_inst),
                    )
                )

            if amail_perso:
                H.append(
                    '<li><a class="stdlink" href="mailto:?bcc=%s">Envoyer un mail collectif au groupe de %s (via %d adresses personnelles)</a></li>'
                    % (
                        ",".join(amail_perso),
                        groups_infos.groups_titles,
                        len(amail_perso),
                    )
                )
            else:
                H.append("<li><em>Adresses personnelles non renseignées</em></li>")

            H.append("</ul>")

        return "".join(H) + "</div>"

    elif (
        format == "pdf"
        or format == "xml"
        or format == "json"
        or format == "xls"
        or format == "moodlecsv"
    ):
        if format == "moodlecsv":
            format = "csv"
        return tab.make_page(format=format)

    elif format == "xlsappel":
        xls = sco_excel.excel_feuille_listeappel(
            groups_infos.formsemestre,
            groups_infos.groups_titles,
            groups_infos.members,
            partitions=groups_infos.partitions,
            with_codes=with_codes,
            with_paiement=with_paiement,
            server_name=request.url_root,
        )
        filename = "liste_%s" % groups_infos.groups_filename + ".xlsx"
        return scu.send_file(
            xls, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE, attached=True
        )
        # return sco_excel.send_excel_file(REQUEST, xls, filename)
    elif format == "allxls":
        # feuille Excel avec toutes les infos etudiants
        if not groups_infos.members:
            return ""
        keys = [
            "etudid",
            "code_nip",
            "etat",
            "civilite_str",
            "nom",
            "nom_usuel",
            "prenom",
            "inscriptionstr",
        ]
        if with_paiement:
            keys.append("paiementinscription")
        keys += [
            "email",
            "emailperso",
            "domicile",
            "villedomicile",
            "codepostaldomicile",
            "paysdomicile",
            "telephone",
            "telephonemobile",
            "fax",
            "date_naissance",
            "lieu_naissance",
            "bac",
            "specialite",
            "annee_bac",
            "nomlycee",
            "villelycee",
            "codepostallycee",
            "codelycee",
            "type_admission",
            "boursier_prec",
            "debouche",
            "parcours",
            "codeparcours",
        ]
        titles = keys[:]
        other_partitions = sco_groups.get_group_other_partitions(groups_infos.groups[0])
        keys += [p["partition_id"] for p in other_partitions]
        titles += [p["partition_name"] for p in other_partitions]
        # remplis infos lycee si on a que le code lycée
        # et ajoute infos inscription
        for m in groups_infos.members:
            etud = sco_etud.get_etud_info(m["etudid"], filled=True)[0]
            m.update(etud)
            sco_etud.etud_add_lycee_infos(etud)
            # et ajoute le parcours
            Se = sco_parcours_dut.SituationEtudParcours(
                etud, groups_infos.formsemestre_id
            )
            m["parcours"] = Se.get_parcours_descr()
            m["codeparcours"], _ = sco_report.get_codeparcoursetud(etud)

        def dicttakestr(d, keys):
            r = []
            for k in keys:
                r.append(str(d.get(k, "")))
            return r

        L = [dicttakestr(m, keys) for m in groups_infos.members]
        title = "etudiants_%s" % groups_infos.groups_filename
        xls = sco_excel.excel_simple_table(titles=titles, lines=L, sheet_name=title)
        filename = title + scu.XLSX_SUFFIX
        return scu.send_file(
            xls, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE, attached=True
        )
        # return sco_excel.send_excel_file(REQUEST, xls, filename)
    else:
        raise ValueError("unsupported format")


def tab_absences_html(groups_infos, etat=None, REQUEST=None):
    """contenu du tab "absences et feuilles diverses" """
    authuser = REQUEST.AUTHENTICATED_USER
    H = ['<div class="tab-content">']
    if not groups_infos.members:
        return "".join(H) + "<h3>Aucun étudiant !</h3></div>"
    H.extend(
        [
            "<h3>Absences</h3>",
            '<ul class="ul_abs">',
            "<li>",
            form_choix_saisie_semaine(groups_infos, REQUEST=REQUEST),  # Ajout Le Havre
            "</li>",
            "<li>",
            form_choix_jour_saisie_hebdo(groups_infos, REQUEST=REQUEST),
            "</li>",
            """<li><a class="stdlink" href="Absences/EtatAbsencesGr?%s&debut=%s&fin=%s">État des absences du groupe</a></li>"""
            % (
                groups_infos.groups_query_args,
                groups_infos.formsemestre["date_debut"],
                groups_infos.formsemestre["date_fin"],
            ),
            "</ul>",
            "<h3>Feuilles</h3>",
            '<ul class="ul_feuilles">',
            """<li><a class="stdlink" href="%s&format=xlsappel">Feuille d'émargement %s (Excel)</a></li>"""
            % (groups_infos.base_url, groups_infos.groups_titles),
            """<li><a class="stdlink" href="trombino?%s&format=pdf">Trombinoscope en PDF</a></li>"""
            % groups_infos.groups_query_args,
            """<li><a class="stdlink" href="pdf_trombino_tours?%s&format=pdf">Trombinoscope en PDF (format "IUT de Tours", beta)</a></li>"""
            % groups_infos.groups_query_args,
            """<li><a class="stdlink" href="pdf_feuille_releve_absences?%s&format=pdf">Feuille relevé absences hebdomadaire (beta)</a></li>"""
            % groups_infos.groups_query_args,
            """<li><a class="stdlink" href="trombino?%s&format=pdflist">Liste d'appel avec photos</a></li>"""
            % groups_infos.groups_query_args,
            "</ul>",
        ]
    )

    H.append('<h3>Opérations diverses</h3><ul class="ul_misc">')
    # Lien pour verif codes INE/NIP
    # (pour tous les etudiants du semestre)
    group_id = sco_groups.get_default_group(groups_infos.formsemestre_id)
    if authuser.has_permission(Permission.ScoEtudInscrit):
        H.append(
            '<li><a class="stdlink" href="check_group_apogee?group_id=%s&etat=%s">Vérifier codes Apogée</a> (de tous les groupes)</li>'
            % (group_id, etat or "")
        )
    # Lien pour ajout fichiers étudiants
    if authuser.has_permission(Permission.ScoEtudAddAnnotations):
        H.append(
            """<li><a class="stdlink" href="etudarchive_import_files_form?group_id=%s">Télécharger des fichiers associés aux étudiants (e.g. dossiers d'admission)</a></li>"""
            % (group_id)
        )

    H.append("</ul></div>")
    return "".join(H)


def tab_photos_html(groups_infos, etat=None, REQUEST=None):
    """contenu du tab "photos" """
    from app.scodoc import sco_trombino

    if not groups_infos.members:
        return '<div class="tab-content"><h3>Aucun étudiant !</h3></div>'

    return sco_trombino.trombino_html(groups_infos, REQUEST=REQUEST)


def form_choix_jour_saisie_hebdo(groups_infos, moduleimpl_id=None, REQUEST=None):
    """Formulaire choix jour semaine pour saisie."""
    authuser = REQUEST.AUTHENTICATED_USER
    if not authuser.has_permission(Permission.ScoAbsChange):
        return ""
    sem = groups_infos.formsemestre
    first_monday = sco_abs.ddmmyyyy(sem["date_debut"]).prev_monday()
    today_idx = datetime.date.today().weekday()

    FA = []  # formulaire avec menu saisi absences
    FA.append(
        '<form id="form_choix_jour_saisie_hebdo" action="Absences/SignaleAbsenceGrSemestre" method="get">'
    )
    FA.append('<input type="hidden" name="datefin" value="%(date_fin)s"/>' % sem)
    FA.append(groups_infos.get_form_elem())
    if moduleimpl_id:
        FA.append(
            '<input type="hidden" name="moduleimpl_id" value="%s"/>' % moduleimpl_id
        )
    FA.append('<input type="hidden" name="destination" value=""/>')

    FA.append(
        """<input type="button" onclick="$('#form_choix_jour_saisie_hebdo')[0].destination.value=get_current_url(); $('#form_choix_jour_saisie_hebdo').submit();" value="Saisir absences du "/>"""
    )
    FA.append("""<select name="datedebut">""")
    date = first_monday
    i = 0
    for jour in sco_abs.day_names():
        if i == today_idx:
            sel = "selected"
        else:
            sel = ""
        i += 1
        FA.append('<option value="%s" %s>%s</option>' % (date, sel, jour))
        date = date.next_day()
    FA.append("</select>")
    FA.append("</form>")
    return "\n".join(FA)


# Ajout Le Havre
# Formulaire saisie absences semaine
def form_choix_saisie_semaine(groups_infos, REQUEST=None):
    authuser = REQUEST.AUTHENTICATED_USER
    if not authuser.has_permission(Permission.ScoAbsChange):
        return ""
    # construit l'URL "destination"
    # (a laquelle on revient apres saisie absences)
    query_args = parse_qs(request.query_string)
    moduleimpl_id = query_args.get("moduleimpl_id", [""])[0]
    if "head_message" in query_args:
        del query_args["head_message"]
    destination = "%s?%s" % (
        request.base_url,
        urllib.parse.urlencode(query_args, True),
    )
    destination = destination.replace(
        "%", "%%"
    )  # car ici utilisee dans un format string !

    DateJour = time.strftime("%d/%m/%Y")
    datelundi = sco_abs.ddmmyyyy(DateJour).prev_monday()
    FA = []  # formulaire avec menu saisie hebdo des absences
    FA.append('<form action="Absences/SignaleAbsenceGrHebdo" method="get">')
    FA.append('<input type="hidden" name="datelundi" value="%s"/>' % datelundi)
    FA.append('<input type="hidden" name="moduleimpl_id" value="%s"/>' % moduleimpl_id)
    FA.append('<input type="hidden" name="destination" value="%s"/>' % destination)
    FA.append(groups_infos.get_form_elem())
    FA.append('<input type="submit" class="button" value="Saisie à la semaine" />')
    FA.append("</form>")
    return "\n".join(FA)


def export_groups_as_moodle_csv(formsemestre_id=None):
    """Export all students/groups, in a CSV format suitable for Moodle
    Each (student,group) will be listed on a separate line
    jo@univ.fr,S3-A
    jo@univ.fr,S3-B1
    if jo belongs to group A in a partition, and B1 in another one.
    Caution: if groups in different partitions share the same name, there will be
    duplicates... should we prefix the group names with the partition's name ?
    """
    if not formsemestre_id:
        raise ScoValueError("missing parameter: formsemestre_id")
    _, partitions_etud_groups = sco_groups.get_formsemestre_groups(
        formsemestre_id, with_default=True
    )
    sem = sco_formsemestre.get_formsemestre(formsemestre_id)
    moodle_sem_name = sem["session_id"]

    columns_ids = ("email", "semestre_groupe")
    T = []
    for partition_id in partitions_etud_groups:
        partition = sco_groups.get_partition(partition_id)
        members = partitions_etud_groups[partition_id]
        for etudid in members:
            etud = sco_etud.get_etud_info(etudid=etudid, filled=True)[0]
            group_name = members[etudid]["group_name"]
            elts = [moodle_sem_name]
            if partition["partition_name"]:
                elts.append(partition["partition_name"])
            if group_name:
                elts.append(group_name)
            T.append({"email": etud["email"], "semestre_groupe": "-".join(elts)})
    # Make table
    prefs = sco_preferences.SemPreferences(formsemestre_id)
    tab = GenTable(
        rows=T,
        columns_ids=("email", "semestre_groupe"),
        filename=moodle_sem_name + "-moodle",
        titles={x: x for x in columns_ids},
        text_fields_separator=prefs["moodle_csv_separator"],
        text_with_titles=prefs["moodle_csv_with_headerline"],
        preferences=prefs,
    )
    return tab.make_page(format="csv")