ScoDoc-PE/app/scodoc/sco_archives_etud.py

330 lines
12 KiB
Python
Raw Normal View History

2020-09-26 16:19:37 +02:00
# -*- mode: python -*-
# -*- coding: utf-8 -*-
##############################################################################
#
# Gestion scolarite IUT
#
2021-01-01 17:51:08 +01:00
# Copyright (c) 1999 - 2021 Emmanuel Viennet. All rights reserved.
2020-09-26 16:19:37 +02:00
#
# 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
#
##############################################################################
"""ScoDoc : gestion des fichiers archivés associés aux étudiants
Il s'agit de fichiers quelconques, généralement utilisés pour conserver
les dossiers d'admission et autres pièces utiles.
"""
import app.scodoc.sco_utils as scu
2021-06-21 10:17:16 +02:00
from app.scodoc import sco_import_etuds
from app.scodoc import sco_groups
from app.scodoc import sco_trombino
from app.scodoc import sco_excel
from app.scodoc import sco_archives
from app.scodoc.sco_permissions import Permission
from app.scodoc.sco_exceptions import AccessDenied
from app.scodoc.TrivialFormulator import TrivialFormulator
from app.scodoc import html_sco_header
from app.scodoc import sco_etud
2020-09-26 16:19:37 +02:00
class EtudsArchiver(sco_archives.BaseArchiver):
def __init__(self):
sco_archives.BaseArchiver.__init__(self, archive_type="docetuds")
EtudsArchive = EtudsArchiver()
def can_edit_etud_archive(context, authuser):
2021-01-01 18:40:47 +01:00
"""True si l'utilisateur peut modifier les archives etudiantes"""
2021-06-15 15:38:38 +02:00
return authuser.has_permission(Permission.ScoEtudAddAnnotations)
2020-09-26 16:19:37 +02:00
def etud_list_archives_html(context, REQUEST, etudid):
2021-01-01 18:40:47 +01:00
"""HTML snippet listing archives"""
2020-09-26 16:19:37 +02:00
can_edit = can_edit_etud_archive(context, REQUEST.AUTHENTICATED_USER)
L = []
for archive_id in EtudsArchive.list_obj_archives(context, etudid):
a = {
"archive_id": archive_id,
"description": EtudsArchive.get_archive_description(archive_id),
"date": EtudsArchive.get_archive_date(archive_id),
"content": EtudsArchive.list_archive(archive_id),
}
L.append(a)
2021-02-04 20:02:44 +01:00
delete_icon = scu.icontag(
2020-09-26 16:19:37 +02:00
"delete_small_img", title="Supprimer fichier", alt="supprimer"
)
2021-02-04 20:02:44 +01:00
delete_disabled_icon = scu.icontag(
2020-09-26 16:19:37 +02:00
"delete_small_dis_img", title="Suppression non autorisée"
)
H = ['<div class="etudarchive"><ul>']
for a in L:
archive_name = EtudsArchive.get_archive_name(a["archive_id"])
H.append(
"""<li><span class ="etudarchive_descr" title="%s">%s</span>"""
% (a["date"].strftime("%d/%m/%Y %H:%M"), a["description"])
)
for filename in a["content"]:
H.append(
2021-05-11 11:48:32 +02:00
"""<a class="stdlink etudarchive_link" href="etud_get_archived_file?etudid=%s&archive_name=%s&filename=%s">%s</a>"""
2020-09-26 16:19:37 +02:00
% (etudid, archive_name, filename, filename)
)
if not a["content"]:
H.append("<em>aucun fichier !</em>")
if can_edit:
H.append(
2021-05-11 11:48:32 +02:00
'<span class="deletudarchive"><a class="smallbutton" href="etud_delete_archive?etudid=%s&archive_name=%s">%s</a></span>'
2020-09-26 16:19:37 +02:00
% (etudid, archive_name, delete_icon)
)
else:
H.append('<span class="deletudarchive">' + delete_disabled_icon + "</span>")
H.append("</li>")
if can_edit:
H.append(
'<li class="addetudarchive"><a class="stdlink" href="etud_upload_file_form?etudid=%s">ajouter un fichier</a></li>'
% etudid
)
H.append("</ul></div>")
return "".join(H)
def add_archives_info_to_etud_list(context, etuds):
"""Add key 'etudarchive' describing archive of etuds
(used to list all archives of a group)
"""
for etud in etuds:
l = []
for archive_id in EtudsArchive.list_obj_archives(context, etud["etudid"]):
l.append(
"%s (%s)"
% (
EtudsArchive.get_archive_description(archive_id),
EtudsArchive.list_archive(archive_id)[0],
)
)
etud["etudarchive"] = ", ".join(l)
def etud_upload_file_form(context, REQUEST, etudid):
2021-01-01 18:40:47 +01:00
"""Page with a form to choose and upload a file, with a description."""
2020-09-26 16:19:37 +02:00
# check permission
if not can_edit_etud_archive(context, REQUEST.AUTHENTICATED_USER):
raise AccessDenied(
"opération non autorisée pour %s" % str(REQUEST.AUTHENTICATED_USER)
)
etud = sco_etud.get_etud_info(filled=1, REQUEST=REQUEST)[0]
2020-09-26 16:19:37 +02:00
H = [
2021-06-14 00:23:22 +02:00
html_sco_header.sco_header(
context,
2020-09-26 16:19:37 +02:00
REQUEST,
page_title="Chargement d'un document associé à %(nomprenom)s" % etud,
),
"""<h2>Chargement d'un document associé à %(nomprenom)s</h2>
"""
% etud,
"""<p>Le fichier ne doit pas dépasser %sMo.</p>
"""
2021-07-09 19:50:40 +02:00
% (scu.CONFIG.ETUD_MAX_FILE_SIZE // (1024 * 1024)),
2020-09-26 16:19:37 +02:00
]
tf = TrivialFormulator(
REQUEST.URL0,
REQUEST.form,
(
("etudid", {"default": etudid, "input_type": "hidden"}),
("datafile", {"input_type": "file", "title": "Fichier", "size": 30}),
(
"description",
{
"input_type": "textarea",
"rows": 4,
"cols": 77,
"title": "Description",
},
),
),
submitlabel="Valider",
cancelbutton="Annuler",
)
if tf[0] == 0:
2021-06-13 18:29:53 +02:00
return "\n".join(H) + tf[1] + html_sco_header.sco_footer(context, REQUEST)
2020-09-26 16:19:37 +02:00
elif tf[0] == -1:
2021-06-15 12:34:33 +02:00
return REQUEST.RESPONSE.redirect(scu.NotesURL() + "/ficheEtud?etudid=" + etudid)
2020-09-26 16:19:37 +02:00
else:
2021-06-25 19:24:12 +02:00
data = tf[2]["datafile"][0].read()
2020-09-26 16:19:37 +02:00
descr = tf[2]["description"]
2021-06-25 19:24:12 +02:00
filename = tf[2]["datafile"][0].filename
2020-09-26 16:19:37 +02:00
_store_etud_file_to_new_archive(
context, REQUEST, etudid, data, filename, description=descr
)
2021-06-25 19:24:12 +02:00
return REQUEST.RESPONSE.redirect(scu.ScoURL() + "/ficheEtud?etudid=" + etudid)
2020-09-26 16:19:37 +02:00
def _store_etud_file_to_new_archive(
context, REQUEST, etudid, data, filename, description=""
):
2021-01-01 18:40:47 +01:00
"""Store data to new archive."""
2020-09-26 16:19:37 +02:00
filesize = len(data)
2021-02-04 20:02:44 +01:00
if filesize < 10 or filesize > scu.CONFIG.ETUD_MAX_FILE_SIZE:
2020-09-26 16:19:37 +02:00
return 0, "Fichier image de taille invalide ! (%d)" % filesize
archive_id = EtudsArchive.create_obj_archive(context, etudid, description)
EtudsArchive.store(archive_id, filename, data)
def etud_delete_archive(context, REQUEST, etudid, archive_name, dialog_confirmed=False):
2021-01-01 18:40:47 +01:00
"""Delete an archive"""
2020-09-26 16:19:37 +02:00
# check permission
if not can_edit_etud_archive(context, REQUEST.AUTHENTICATED_USER):
raise AccessDenied(
"opération non autorisée pour %s" % str(REQUEST.AUTHENTICATED_USER)
)
etud = sco_etud.get_etud_info(filled=1, REQUEST=REQUEST)[0]
2020-09-26 16:19:37 +02:00
archive_id = EtudsArchive.get_id_from_name(context, etudid, archive_name)
dest_url = "ficheEtud?etudid=%s" % etudid
if not dialog_confirmed:
return scu.confirm_dialog(
context,
2020-09-26 16:19:37 +02:00
"""<h2>Confirmer la suppression des fichiers ?</h2>
<p>Fichier associé le %s à l'étudiant %s</p>
<p>La suppression sera définitive.</p>"""
% (
EtudsArchive.get_archive_date(archive_id).strftime("%d/%m/%Y %H:%M"),
etud["nomprenom"],
),
dest_url="",
REQUEST=REQUEST,
cancel_url=dest_url,
parameters={"etudid": etudid, "archive_name": archive_name},
)
EtudsArchive.delete_archive(archive_id)
2021-05-11 11:48:32 +02:00
return REQUEST.RESPONSE.redirect(dest_url + "&head_message=Archive%20supprimée")
2020-09-26 16:19:37 +02:00
def etud_get_archived_file(context, REQUEST, etudid, archive_name, filename):
2021-01-01 18:40:47 +01:00
"""Send file to client."""
2020-09-26 16:19:37 +02:00
return EtudsArchive.get_archived_file(
context, REQUEST, etudid, archive_name, filename
)
# --- Upload d'un ensemble de fichiers (pour un groupe d'étudiants)
def etudarchive_generate_excel_sample(context, group_id=None, REQUEST=None):
2021-01-01 18:40:47 +01:00
"""Feuille excel pour import fichiers etudiants (utilisé pour admissions)"""
2021-06-21 10:17:16 +02:00
fmt = sco_import_etuds.sco_import_format()
data = sco_import_etuds.sco_import_generate_excel_sample(
2020-09-26 16:19:37 +02:00
fmt,
context=context,
group_ids=[group_id],
only_tables=["identite"],
exclude_cols=[
"date_naissance",
"lieu_naissance",
"nationalite",
"statut",
"photo_filename",
],
extra_cols=["fichier_a_charger"],
REQUEST=REQUEST,
)
return sco_excel.sendExcelFile(REQUEST, data, "ImportFichiersEtudiants.xls")
def etudarchive_import_files_form(context, group_id, REQUEST=None):
2021-07-05 23:53:23 +02:00
"""Formulaire pour importation fichiers d'un groupe"""
2020-09-26 16:19:37 +02:00
H = [
2021-06-14 00:23:22 +02:00
html_sco_header.sco_header(
context, REQUEST, page_title="Import de fichiers associés aux étudiants"
2020-09-26 16:19:37 +02:00
),
"""<h2 class="formsemestre">Téléchargement de fichier associés aux étudiants</h2>
<p>Les fichiers associés (dossiers d'admission, certificats, ...), de types quelconques (pdf, doc, images)
sont accessibles aux utilisateurs via la fiche individuelle de l'étudiant.
</p>
<p class="warning">Ne pas confondre avec les photos des étudiants, qui se chargent via l'onglet "Photos".</p>
<p><b>Vous pouvez aussi charger à tout moment de nouveaux fichiers, ou en supprimer, via la fiche de chaque étudiant.</b></p>
<p class="help">Cette page permet de charger en une seule fois les fichiers de plusieurs étudiants.<br/>
Il faut d'abord remplir une feuille excel donnant les noms
des fichiers (un fichier par étudiant).
</p>
<p class="help">Ensuite, réunir vos fichiers dans un fichier zip, puis télécharger
simultanément le fichier excel et le fichier zip.
</p>
<ol>
<li><a class="stdlink" href="etudarchive_generate_excel_sample?group_id=%s">
Obtenir la feuille excel à remplir</a>
</li>
<li style="padding-top: 2em;">
"""
% group_id,
]
2021-06-13 18:29:53 +02:00
F = html_sco_header.sco_footer(context, REQUEST)
2020-09-26 16:19:37 +02:00
tf = TrivialFormulator(
REQUEST.URL0,
REQUEST.form,
(
("xlsfile", {"title": "Fichier Excel:", "input_type": "file", "size": 40}),
("zipfile", {"title": "Fichier zip:", "input_type": "file", "size": 40}),
(
"description",
{
"input_type": "textarea",
"rows": 4,
"cols": 77,
"title": "Description",
},
),
("group_id", {"input_type": "hidden"}),
),
)
if tf[0] == 0:
return "\n".join(H) + tf[1] + "</li></ol>" + F
elif tf[0] == -1:
# retrouve le semestre à partir du groupe:
g = sco_groups.get_group(context, group_id)
return REQUEST.RESPONSE.redirect(
"formsemestre_status?formsemestre_id=" + g["formsemestre_id"]
)
else:
return etudarchive_import_files(
context,
group_id=tf[2]["group_id"],
xlsfile=tf[2]["xlsfile"],
zipfile=tf[2]["zipfile"],
REQUEST=REQUEST,
description=tf[2]["description"],
)
def etudarchive_import_files(
context, group_id=None, xlsfile=None, zipfile=None, REQUEST=None, description=""
):
def callback(context, etud, data, filename, REQUEST):
_store_etud_file_to_new_archive(
context, REQUEST, etud["etudid"], data, filename, description
)
filename_title = "fichier_a_charger"
page_title = "Téléchargement de fichiers associés aux étudiants"
# Utilise la fontion au depart developpee pour les photos
r = sco_trombino.zip_excel_import_files(
context, xlsfile, zipfile, REQUEST, callback, filename_title, page_title
)
2021-06-13 18:29:53 +02:00
return r + html_sco_header.sco_footer(context, REQUEST)