forked from ScoDoc/ScoDoc
523 lines
19 KiB
Python
523 lines
19 KiB
Python
import openpyxl
|
|
from openpyxl.worksheet.worksheet import Worksheet
|
|
|
|
from app.but.prepajury_xl_format import (
|
|
SCO_COLORS,
|
|
FMT,
|
|
SCO_FONTSIZE,
|
|
SCO_VALIGN,
|
|
SCO_HALIGN,
|
|
SCO_BORDERTHICKNESS,
|
|
Sco_Style,
|
|
HAIR_BLACK,
|
|
SCO_NUMBER_FORMAT,
|
|
)
|
|
from app.comp import res_sem
|
|
from app.models import ApcCompetence, ApcParcours, FormSemestre
|
|
from app.but.prepajury_xl import (
|
|
ScoExcelBook,
|
|
ScoExcelSheet,
|
|
base_signature,
|
|
Frame_Engine,
|
|
Merge_Engine,
|
|
)
|
|
|
|
|
|
UNUSED = "XXX"
|
|
liste_annees = ["BUT1", "BUT2", "BUT3"]
|
|
header_colors = {
|
|
"BUT1": {
|
|
"BUT": SCO_COLORS.BUT1,
|
|
"RCUE": SCO_COLORS.RCUE1,
|
|
"UE": SCO_COLORS.UE1,
|
|
},
|
|
"BUT2": {
|
|
"BUT": SCO_COLORS.BUT2,
|
|
"RCUE": SCO_COLORS.RCUE2,
|
|
"UE": SCO_COLORS.UE2,
|
|
},
|
|
"BUT3": {
|
|
"BUT": SCO_COLORS.BUT3,
|
|
"RCUE": SCO_COLORS.RCUE3,
|
|
"UE": SCO_COLORS.UE3,
|
|
},
|
|
}
|
|
|
|
|
|
def periode(semestre_idx):
|
|
return 1 + (semestre_idx + 1) % 2
|
|
|
|
|
|
class UeDesc:
|
|
def __init__(self, scodocUe, competence_id, periode):
|
|
self.fromScodoc = scodocUe
|
|
self.competence_id = competence_id
|
|
self.periode = periode
|
|
|
|
|
|
class NiveauDesc:
|
|
def __init__(self, scodocNiveau):
|
|
self.fromScodoc = scodocNiveau
|
|
self.ues = {1: None, 2: None}
|
|
for scodocUe in scodocNiveau.ues:
|
|
ue_desc = UeDesc(
|
|
scodocUe, scodocNiveau.competence_id, periode(scodocUe.semestre_idx)
|
|
)
|
|
self.ues[periode(scodocUe.semestre_idx)] = scodocUe
|
|
if not scodocUe.is_external:
|
|
self.ues[periode(scodocUe.semestre_idx)] = scodocUe
|
|
|
|
def get_desc(self, periode=None):
|
|
if periode is None:
|
|
return self
|
|
return self.ues.get(periode, None)
|
|
|
|
def generate_data(
|
|
self, ws: ScoExcelSheet, row: int, etudiant: "EtudiantJury", column: int
|
|
) -> int:
|
|
for periode in [1, 2]:
|
|
ue = self.ues[periode]
|
|
if ue is None:
|
|
ws.set_cell(row, column, UNUSED)
|
|
ws.set_cell(row, column + 1, UNUSED)
|
|
else:
|
|
ws.set_cell(
|
|
row,
|
|
column,
|
|
etudiant.get_note(
|
|
self.fromScodoc.annee, self.fromScodoc.competence_id, periode
|
|
),
|
|
base_signature,
|
|
)
|
|
ws.set_cell(
|
|
row,
|
|
column + 1,
|
|
etudiant.get_res(
|
|
self.fromScodoc.annee, self.fromScodoc.competence_id, periode
|
|
),
|
|
)
|
|
column += 2
|
|
ws.set_cell(
|
|
row,
|
|
column,
|
|
etudiant.get_note(self.fromScodoc.annee, self.fromScodoc.competence_id),
|
|
base_signature,
|
|
)
|
|
ws.set_cell(
|
|
row,
|
|
column + 1,
|
|
etudiant.get_res(self.fromScodoc.annee, self.fromScodoc.competence_id),
|
|
)
|
|
return column + 2
|
|
|
|
@staticmethod
|
|
def generate_blank_data(ws: ScoExcelSheet, row: int, column: int) -> int:
|
|
ws.set_cell(row, column + 0, "UN1")
|
|
ws.set_cell(row, column + 1, "UR1")
|
|
ws.set_cell(row, column + 2, "UN2")
|
|
ws.set_cell(row, column + 3, "UR2")
|
|
ws.set_cell(row, column + 4, "R1")
|
|
ws.set_cell(row, column + 5, "R2")
|
|
column += 6
|
|
return column
|
|
|
|
@staticmethod
|
|
def generate_blank_header(ws: ScoExcelSheet, column: int, annee: str):
|
|
rcue_signature = FMT.FILL_BGCOLOR.write(
|
|
value=header_colors[annee]["RCUE"].value,
|
|
signature=base_signature,
|
|
)
|
|
ue_signature = FMT.FILL_BGCOLOR.write(
|
|
value=header_colors[annee]["UE"].value,
|
|
signature=base_signature,
|
|
)
|
|
merge = ws.get_merge_engine(start_row=2, start_column=column)
|
|
frame = ws.get_frame_engine(
|
|
start_row=2, start_column=column, thickness=SCO_BORDERTHICKNESS.BORDER_THIN
|
|
)
|
|
ws.set_cell(2, column, UNUSED, from_signature=rcue_signature)
|
|
for ue in ["UE1", "UE2"]:
|
|
frame_ue = ws.get_frame_engine(
|
|
start_row=3,
|
|
start_column=column,
|
|
thickness=SCO_BORDERTHICKNESS.BORDER_THIN,
|
|
color=SCO_COLORS.GREY,
|
|
)
|
|
merge_ue = ws.get_merge_engine(start_row=3, start_column=column)
|
|
ws.set_cell(3, column, UNUSED, ue_signature)
|
|
ws.set_cell(4, column, "Note", ue_signature)
|
|
ws.set_column_dimension_hidden(ScoExcelSheet.i2col(column - 1), True)
|
|
column += 1
|
|
ws.set_cell(4, column, "Rés.", ue_signature)
|
|
ws.set_column_dimension_hidden(ScoExcelSheet.i2col(column - 1), True)
|
|
column += 1
|
|
merge_ue.close(end_row=3, end_column=column - 1)
|
|
frame_ue.close(end_row=4, end_column=column - 1)
|
|
merge_rcue = ws.get_merge_engine(start_row=3, start_column=column)
|
|
ws.set_cell(3, column, UNUSED, rcue_signature)
|
|
ws.set_cell(4, column, UNUSED, rcue_signature)
|
|
ws.set_column_dimension_hidden(ScoExcelSheet.i2col(column - 1), True)
|
|
column += 1
|
|
ws.set_cell(4, column, UNUSED, rcue_signature)
|
|
ws.set_column_dimension_hidden(ScoExcelSheet.i2col(column - 1), True)
|
|
column += 1
|
|
merge_rcue.close(end_row=3, end_column=column - 1)
|
|
frame.close(end_row=4, end_column=column - 1)
|
|
merge.close(end_row=2, end_column=column - 1)
|
|
return column
|
|
|
|
def generate_header(self, ws: ScoExcelSheet, column: int):
|
|
rcue_signature = FMT.FILL_BGCOLOR.write(
|
|
value=header_colors[self.fromScodoc.annee]["RCUE"].value,
|
|
signature=base_signature,
|
|
)
|
|
ue_signature = FMT.FILL_BGCOLOR.write(
|
|
value=header_colors[self.fromScodoc.annee]["UE"].value,
|
|
signature=base_signature,
|
|
)
|
|
merge = ws.get_merge_engine(start_row=2, start_column=column)
|
|
frame = ws.get_frame_engine(
|
|
start_row=2, start_column=column, thickness=SCO_BORDERTHICKNESS.BORDER_THIN
|
|
)
|
|
ws.set_cell(
|
|
2, column, self.fromScodoc.competence.titre, from_signature=rcue_signature
|
|
)
|
|
for periode in [1, 2]:
|
|
ue = self.ues[periode]
|
|
frame_ue = ws.get_frame_engine(
|
|
start_row=3,
|
|
start_column=column,
|
|
thickness=SCO_BORDERTHICKNESS.BORDER_THIN,
|
|
color=SCO_COLORS.GREY,
|
|
)
|
|
merge_ue = ws.get_merge_engine(start_row=3, start_column=column)
|
|
if ue is None:
|
|
ws.set_cell(3, column, "XXX", ue_signature)
|
|
else:
|
|
ws.set_cell(3, column, ue.acronyme, ue_signature)
|
|
ws.set_cell(4, column, "Note", ue_signature)
|
|
column += 1
|
|
ws.set_cell(4, column, "Rés.", ue_signature)
|
|
column += 1
|
|
merge_ue.close(end_row=3, end_column=column - 1)
|
|
frame_ue.close(end_row=4, end_column=column - 1)
|
|
merge_rcue = ws.get_merge_engine(start_row=3, start_column=column)
|
|
ws.set_cell(3, column, "Competence", rcue_signature)
|
|
ws.set_cell(4, column, "Note", rcue_signature)
|
|
column += 1
|
|
ws.set_cell(4, column, "Rés.", rcue_signature)
|
|
column += 1
|
|
merge_rcue.close(end_row=3, end_column=column - 1)
|
|
frame.close(end_row=4, end_column=column - 1)
|
|
merge.close(end_row=2, end_column=column - 1)
|
|
return column
|
|
|
|
def get_ues(self, etudiant):
|
|
"""get list of candidates UEs for Niveau"""
|
|
ues = [None, None]
|
|
for inscription in etudiant.cursus.inscriptions:
|
|
formation_id = inscription.formsemestre.formation_id
|
|
semestre_idx = inscription.formsemestre.semestre_id
|
|
if semestre_idx in self.ues:
|
|
# identifier les ues cocernées
|
|
ues[periode(semestre_idx)] = inscription.formsemestre
|
|
return ues
|
|
|
|
|
|
class CompetenceDesc:
|
|
def __init__(self, scodocCompetence):
|
|
self.fromScodoc: ApcCompetence = scodocCompetence
|
|
self.niveaux = {}
|
|
for scodocNiveau in scodocCompetence.niveaux.all():
|
|
self.niveaux[scodocNiveau.id] = NiveauDesc(scodocNiveau)
|
|
|
|
def getNiveauDesc(self, niveau_id):
|
|
return self.niveaux[niveau_id]
|
|
|
|
def getNiveaux(self, codeAnnee):
|
|
niveaux = []
|
|
for niveau_id, niveauDesc in self.niveaux.items():
|
|
if codeAnnee == niveauDesc.fromScodoc.annee:
|
|
niveaux.append(niveauDesc)
|
|
return niveaux
|
|
|
|
|
|
class FormsemestreDesc:
|
|
def __init__(self, formsemestre_id, formsemestre=None):
|
|
self.formsemestre_id = formsemestre_id
|
|
self.formsemestre = formsemestre
|
|
self.resultats = None
|
|
|
|
def get_desc(self, competence_id=None):
|
|
if competence_id is None:
|
|
return self
|
|
return self.ues.get(competence_id, None)
|
|
|
|
def get_formsemestre(self):
|
|
if self.formsemestre is None:
|
|
self.formsemestre = FormSemestre.get(self.formsemestre_id)
|
|
return self.formsemestre
|
|
|
|
def get_resultats(self):
|
|
if self.resultats is None:
|
|
self.resultats = res_sem.load_formsemestre_results(self.get_formsemestre())
|
|
return self.resultats
|
|
|
|
|
|
class AnneeDesc:
|
|
def __init__(self, codeAnnee):
|
|
self.codeAnnee = codeAnnee
|
|
self.niveaux = {}
|
|
|
|
def get_desc(self, competence_id=None, periode=None):
|
|
if competence_id is None and periode is None:
|
|
return self
|
|
elif competence_id is None:
|
|
return self.formsemestres.get(periode, None)
|
|
elif competence_id in self.niveaux:
|
|
return self.niveaux[competence_id].get_desc(periode)
|
|
else:
|
|
return None
|
|
|
|
def addNiveau(self, niveaux):
|
|
for niveau in niveaux:
|
|
competence_id = niveau.fromScodoc.competence_id
|
|
self.niveaux[competence_id] = niveau
|
|
|
|
def generate_blank_niveau(self, ws: ScoExcelSheet, column: int):
|
|
return column
|
|
|
|
def generate_data(
|
|
self, ws: ScoExcelSheet, row: int, etudiant: "EtudiantJury", column: int
|
|
) -> int:
|
|
for niveau in self.niveaux.values():
|
|
column = niveau.generate_data(ws, row, etudiant, column)
|
|
for i in range(len(self.niveaux), 6):
|
|
column = NiveauDesc.generate_blank_data(ws, row, column)
|
|
ws.set_cell(row, column + 0, "A1")
|
|
ws.set_cell(row, column + 1, etudiant.get_note(self.codeAnnee), base_signature)
|
|
ws.set_cell(row, column + 2, etudiant.get_res(self.codeAnnee))
|
|
column += 3
|
|
if self.codeAnnee == "BUT2":
|
|
# ws.set_cell(row, column, etudiant.getDipl("BUT2"))
|
|
column += 1
|
|
if self.codeAnnee == "BUT3":
|
|
# ws.set_cell(row, column, etudiant.getDipl("BUT3"))
|
|
column += 1
|
|
return column
|
|
|
|
def generate_header(self, ws: ScoExcelSheet, column: int):
|
|
start = column
|
|
but_signature = FMT.FILL_BGCOLOR.write(
|
|
signature=base_signature, value=header_colors[self.codeAnnee]["BUT"].value
|
|
)
|
|
merge = ws.get_merge_engine(start_row=1, start_column=column)
|
|
frame = ws.get_frame_engine(
|
|
start_row=1, start_column=column, thickness=SCO_BORDERTHICKNESS.BORDER_THICK
|
|
)
|
|
ws.set_cell(
|
|
1,
|
|
column,
|
|
text=self.codeAnnee,
|
|
from_signature=but_signature,
|
|
composition=[
|
|
(FMT.BORDER_LEFT_COLOR, SCO_COLORS.BLACK.value),
|
|
(FMT.BORDER_LEFT_STYLE, SCO_BORDERTHICKNESS.BORDER_MEDIUM.value),
|
|
],
|
|
)
|
|
for niveau in self.niveaux.values():
|
|
column = niveau.generate_header(ws, column)
|
|
for i in range(len(self.niveaux), 6):
|
|
column = NiveauDesc.generate_blank_header(ws, column, self.codeAnnee)
|
|
merge_annee = ws.get_merge_engine(start_row=2, start_column=column)
|
|
ws.set_cell(2, column, "Année", from_signature=but_signature)
|
|
# cell_format(ws.cell(2, column), but_signature, [(FMT.FONT_BOLD, True)])
|
|
ws.set_cell(3, column, "Nb", from_signature=but_signature)
|
|
ws.set_cell(4, column, "RCUE", from_signature=but_signature)
|
|
column += 1
|
|
ws.set_cell(3, column, from_signature=but_signature)
|
|
ws.set_cell(3, column, "Moy.", from_signature=but_signature)
|
|
ws.set_cell(4, column, f"Sem", from_signature=but_signature)
|
|
column += 1
|
|
ws.set_cell(3, column, from_signature=but_signature)
|
|
ws.set_cell(4, column, "Rés.", from_signature=but_signature)
|
|
column += 1
|
|
merge_annee.close(end_row=2, end_column=column - 1)
|
|
if self.codeAnnee == "BUT2":
|
|
ws.set_cell(2, column, "DUT", from_signature=but_signature)
|
|
ws.set_cell(3, column, from_signature=but_signature)
|
|
ws.set_cell(4, column, "Rés.", from_signature=but_signature)
|
|
column += 1
|
|
if self.codeAnnee == "BUT3":
|
|
ws.set_cell(2, column, "BUT", from_signature=but_signature)
|
|
ws.set_cell(3, column, from_signature=but_signature)
|
|
ws.set_cell(4, column, "Rés.", from_signature=but_signature)
|
|
column += 1
|
|
frame.close(end_row=4, end_column=column - 1)
|
|
merge.close(end_row=1, end_column=column - 1)
|
|
return column
|
|
|
|
|
|
class ParcoursDesc:
|
|
signature_header = FMT.compose(
|
|
[
|
|
(FMT.FILL_BGCOLOR, SCO_COLORS.LIGHT_YELLOW.value),
|
|
(FMT.NUMBER_FORMAT, SCO_NUMBER_FORMAT.NUMBER_GENERAL.value),
|
|
# (FMT.FONT_BOLD, True),
|
|
# (FMT.FONT_SIZE, SCO_FONTSIZE.FONTSIZE_13.value),
|
|
# (FMT.ALIGNMENT_VALIGN, SCO_VALIGN.VALIGN_CENTER.value),
|
|
# (FMT.ALIGNMENT_HALIGN, SCO_HALIGN.HALIGN_CENTER.value),
|
|
# (FMT.BORDER_RIGHT, HAIR_BLACK),
|
|
# (FMT.BORDER_LEFT, HAIR_BLACK),
|
|
# (FMT.BORDER_TOP, HAIR_BLACK),
|
|
# (FMT.BORDER_BOTTOM, HAIR_BLACK),
|
|
],
|
|
base_signature,
|
|
)
|
|
|
|
def __init__(self, formation, scodocParcour: ApcParcours = None):
|
|
self.fromScodoc: ApcParcours = scodocParcour # None pour le tronc commun 'TC'
|
|
self.etudiants = []
|
|
self.competences = {}
|
|
self.annees = {}
|
|
if scodocParcour is None:
|
|
for (
|
|
scodocCompetence
|
|
) in formation.referentiel_competence.get_competences_tronc_commun():
|
|
self.competences[scodocCompetence.id] = CompetenceDesc(scodocCompetence)
|
|
else:
|
|
query = formation.query_competences_parcour(scodocParcour)
|
|
if not query is None:
|
|
for scodocCompetence in query.all():
|
|
self.competences[scodocCompetence.id] = CompetenceDesc(
|
|
scodocCompetence
|
|
)
|
|
for codeAnnee in liste_annees:
|
|
annee_desc = AnneeDesc(codeAnnee)
|
|
for competence_id, competence in self.competences.items():
|
|
annee_desc.addNiveau(competence.getNiveaux(codeAnnee))
|
|
self.annees[codeAnnee] = annee_desc
|
|
|
|
def get_desc(self, annee=None, competence_id=None, periode=None):
|
|
if annee is None:
|
|
return self
|
|
if annee in self.annees:
|
|
return self.annees[annee].get_desc(competence_id, periode)
|
|
return None
|
|
|
|
def add_etudiant(self, etudiant):
|
|
if not etudiant in self.etudiants:
|
|
self.etudiants.append(etudiant)
|
|
|
|
def getNiveauDesc(self, competence_id, niveau_id):
|
|
return self.competences[competence_id].getNiveauDesc(niveau_id)
|
|
|
|
def getData(self):
|
|
data = []
|
|
for etudiant in self.etudiants:
|
|
data.append(etudiant.get_data())
|
|
return data
|
|
|
|
def append_title_column(self, worksheet, cells, val1, val2, val3, val4):
|
|
cells1, cells2, cells3, cells4 = cells
|
|
cells1.append(worksheet.make_cell(val1))
|
|
cells2.append(worksheet.make_cell(val2))
|
|
cells3.append(worksheet.make_cell(val3))
|
|
cells4.append(worksheet.make_cell(val4))
|
|
|
|
def handle_description(
|
|
self, ws: ScoExcelSheet, description: tuple, row: int, column: int
|
|
) -> int:
|
|
title, content_list = description
|
|
frame_thickness, frame_color = [
|
|
(SCO_BORDERTHICKNESS.BORDER_THICK, SCO_COLORS.BLACK),
|
|
(SCO_BORDERTHICKNESS.BORDER_HAIR, SCO_COLORS.BLACK),
|
|
(SCO_BORDERTHICKNESS.BORDER_HAIR, SCO_COLORS.BLACK),
|
|
(SCO_BORDERTHICKNESS.NONE, SCO_COLORS.NONE),
|
|
][row - 1]
|
|
frame = ws.get_frame_engine(
|
|
start_row=row,
|
|
start_column=column,
|
|
thickness=frame_thickness,
|
|
color=frame_color,
|
|
)
|
|
ws.set_cell(
|
|
row=row,
|
|
column=column,
|
|
text=title,
|
|
from_signature=self.signature_header,
|
|
)
|
|
merge_h = ws.get_merge_engine(start_row=row, start_column=column)
|
|
merge_v = ws.get_merge_engine(start_row=row, start_column=column)
|
|
if content_list is None:
|
|
merge_v.close(end_row=4)
|
|
column += 1
|
|
else:
|
|
for content in content_list:
|
|
column = self.handle_description(ws, content, row + 1, column)
|
|
merge_h.close(end_column=column - 1)
|
|
frame.close(4, column - 1)
|
|
return column
|
|
|
|
def generate_etudiant_header(self, ws: ScoExcelSheet) -> int:
|
|
titles = (
|
|
"ETUDIANT",
|
|
[
|
|
("id", None),
|
|
("nip", None),
|
|
("Civ", None),
|
|
("nom", None),
|
|
("prenom", None),
|
|
("parcours", None),
|
|
("cursus", None),
|
|
(
|
|
"absences",
|
|
[
|
|
("Tot.", None),
|
|
("Non", [("Just.", None)]),
|
|
],
|
|
),
|
|
],
|
|
)
|
|
column = self.handle_description(ws, titles, 1, 1)
|
|
return column
|
|
|
|
def generate_header(self, ws: ScoExcelSheet):
|
|
column: int = self.generate_etudiant_header(ws)
|
|
for codeAnnee in liste_annees:
|
|
column = self.annees[codeAnnee].generate_header(ws, column)
|
|
|
|
def generate(self, workbook: ScoExcelBook):
|
|
if self.fromScodoc:
|
|
sheet_name = self.fromScodoc.code
|
|
else:
|
|
sheet_name = "TC"
|
|
worksheet: ScoExcelSheet = workbook.create_sheet(sheet_name)
|
|
self.generate_header(worksheet)
|
|
self.generate_etudiants(worksheet)
|
|
|
|
def generate_data(
|
|
self, ws: ScoExcelSheet, row: int, column: int, etudiant: "EtudiantJury"
|
|
):
|
|
for codeAnnee in liste_annees:
|
|
column = self.annees[codeAnnee].generate_data(ws, row, etudiant, column)
|
|
|
|
def generate_etudiants(self, ws: ScoExcelSheet):
|
|
ligne = 5
|
|
for etudiant in self.etudiants:
|
|
ws.set_cell(ligne, 1, etudiant.ident.id)
|
|
ws.set_cell(ligne, 2, etudiant.ident.code_nip)
|
|
ws.set_cell(ligne, 3, etudiant.ident.civilite)
|
|
ws.set_cell(ligne, 4, etudiant.ident.nom)
|
|
ws.set_cell(ligne, 5, etudiant.ident.prenom)
|
|
if etudiant.parcour:
|
|
ws.set_cell(ligne, 6, etudiant.parcour.code)
|
|
else:
|
|
ws.set_cell(ligne, 6, "-")
|
|
cursus = ", ".join(etudiant.history)
|
|
ws.set_cell(ligne, 7, cursus)
|
|
ws.set_cell(ligne, 8, etudiant.nbabs)
|
|
ws.set_cell(ligne, 9, etudiant.nbabs - etudiant.nbabsjust)
|
|
# self.generate_data(ws, ligne, 10, etudiant)
|
|
ligne = ligne + 1
|