ScoDocMM/config/postupgrade-db.py

1113 lines
39 KiB
Python
Raw Normal View History

2020-09-26 16:19:37 +02:00
#!/opt/zope213/bin/python
# -*- coding: utf-8 -*-
"""
ScoDoc post-upgrade script: databases housekeeping
This script is runned by upgrade.sh after each SVN update.
Runned as "www-data" with Zope shutted down and postgresql up.
Useful to update database schema (eg add new tables or columns to
existing scodoc instances).
E. Viennet, june 2008, sept 2013
"""
from scodocutils import *
for dept in get_depts():
log("\nChecking database for dept %s" % dept)
2020-09-26 16:19:37 +02:00
cnx_string = None
try:
cnx_string = get_dept_cnx_str(dept)
cnx = psycopg2.connect(cnx_string)
2020-09-26 16:19:37 +02:00
except:
log("\n*** Error: departement %s not upgraded ! ***\n" % dept)
log('connexion string was "%s"' % cnx_string)
2020-09-26 16:19:37 +02:00
traceback.print_exc()
continue
cnx.set_session(autocommit=False)
cursor = cnx.cursor()
# Apply upgrades:
2020-09-26 16:19:37 +02:00
# SVN 564 -> 565
# add resp_can_edit to notes_formsemestre:
check_field(
cnx,
"notes_formsemestre",
"resp_can_edit",
[
"alter table notes_formsemestre add column resp_can_edit int default 0",
"update notes_formsemestre set resp_can_edit=0",
],
)
2020-09-26 16:19:37 +02:00
# SVN 580 -> 581
# add resp_can_change_ens to notes_formsemestre:
check_field(
cnx,
"notes_formsemestre",
"resp_can_change_ens",
[
"alter table notes_formsemestre add column resp_can_change_ens int default 1",
"update notes_formsemestre set resp_can_change_ens=1",
],
)
2020-09-26 16:19:37 +02:00
# Fix bug ayant empeche la creation de la table
check_table(
cnx,
"admissions",
[
"""CREATE TABLE admissions (
2020-09-26 16:19:37 +02:00
adm_id text DEFAULT notes_newid_etud('ADM'::text) NOT NULL,
etudid text NOT NULL,
annee integer,
bac text,
specialite text,
annee_bac integer,
math real,
physique real,
anglais real,
francais real,
rang integer, -- dans les voeux du candidat (inconnu avec APB)
qualite real,
rapporteur text,
decision text,
score real,
commentaire text,
nomlycee text,
villelycee text,
codepostallycee text,
codelycee text,
debouche text, -- situation APRES etre passe par chez nous (texte libre)
type_admission text, -- 'APB', 'APC-PC', 'CEF', 'Direct', '?' (autre)
boursier_prec integer default NULL, -- etait boursier dans le cycle precedent (lycee) ?
classement integer default NULL, -- classement par le jury d'admission (1 à N), global (pas celui d'APB si il y a des groupes)
apb_groupe text, -- code du groupe APB
apb_classement_gr integer default NULL -- classement (1..Ngr) par le jury dans le groupe APB
) WITH OIDS;
"""
],
)
2020-09-26 16:19:37 +02:00
# SVN 651
# Nouvelles donnees d'admission
check_field(
cnx,
"admissions",
"codelycee",
[
"alter table admissions add column codelycee text",
],
)
check_field(
cnx,
"admissions",
"codepostallycee",
[
"alter table admissions add column codepostallycee text",
],
)
2020-09-26 16:19:37 +02:00
# New preferences system
check_field(
cnx,
"sco_prefs",
"formsemestre_id",
[
"alter table sco_prefs add column pref_id text DEFAULT notes_newid('PREF'::text) UNIQUE NOT NULL",
"update sco_prefs set pref_id=oid",
"alter table sco_prefs add column formsemestre_id text default NULL",
"alter table sco_prefs drop CONSTRAINT sco_prefs_pkey",
"alter table sco_prefs add unique( name, formsemestre_id)",
# copie anciennes prefs:
"insert into sco_prefs (name, value, formsemestre_id) select 'left_margin', left_margin, formsemestre_id from notes_formsemestre_pagebulletin",
"insert into sco_prefs (name, value, formsemestre_id) select 'top_margin', top_margin, formsemestre_id from notes_formsemestre_pagebulletin",
"insert into sco_prefs (name, value, formsemestre_id) select 'right_margin', right_margin, formsemestre_id from notes_formsemestre_pagebulletin",
"insert into sco_prefs (name, value, formsemestre_id) select 'bottom_margin', bottom_margin, formsemestre_id from notes_formsemestre_pagebulletin",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_title', title, formsemestre_id from notes_formsemestre_pagebulletin",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_intro_mail', intro_mail, formsemestre_id from notes_formsemestre_pagebulletin",
"drop table notes_formsemestre_pagebulletin",
# anciens champs de formsemestre:
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_abs', gestion_absence, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column gestion_absence",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_decision', bul_show_decision, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column bul_show_decision",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_uevalid', bul_show_uevalid, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column bul_show_uevalid",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_codemodules', bul_show_codemodules, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column bul_show_codemodules",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_rangs', bul_show_rangs, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column bul_show_rangs",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_ue_rangs', bul_show_ue_rangs, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column bul_show_ue_rangs",
"insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_mod_rangs', bul_show_mod_rangs, formsemestre_id from notes_formsemestre",
"alter table notes_formsemestre drop column bul_show_mod_rangs",
],
)
2020-09-26 16:19:37 +02:00
# fixed previous bug (misspelled pref)
cursor.execute(
"update sco_prefs set name = 'bul_show_codemodules' where name = 'bul_showcodemodules'"
)
2020-09-26 16:19:37 +02:00
# billets d'absences
if not sequence_exists(cnx, "notes_idgen_billets"):
log("creating sequence notes_idgen_billets")
cursor.execute("CREATE SEQUENCE notes_idgen_billets;")
if not function_exists(cnx, "notes_newid_billet"):
log("creating function notes_newid_billet")
cursor.execute(
"""CREATE FUNCTION notes_newid_billet( text ) returns text as '
2020-09-26 16:19:37 +02:00
select $1 || to_char( nextval(''notes_idgen_billets''), ''FM999999999'' )
as result;
' language SQL;"""
)
check_table(
cnx,
"billet_absence",
[
2020-09-26 16:19:37 +02:00
"""CREATE TABLE billet_absence (
billet_id text DEFAULT notes_newid_billet('B'::text) NOT NULL,
etudid text NOT NULL,
abs_begin timestamp with time zone,
abs_end timestamp with time zone,
description text, -- "raison" de l'absence
etat integer default 0 -- 0 new, 1 processed
) WITH OIDS;
"""
],
)
2020-09-26 16:19:37 +02:00
# description absence
check_field(
cnx,
"absences",
"description",
["alter table absences add column description text"],
)
check_field(
cnx,
"absences",
"entry_date",
[
"alter table absences add column entry_date timestamp with time zone DEFAULT now()"
],
)
check_field(
cnx,
"billet_absence",
"entry_date",
[
"alter table billet_absence add column entry_date timestamp with time zone DEFAULT now()"
],
)
2020-09-26 16:19:37 +02:00
# Nouvelles preferences pour bulletins PDF: migre bul_show_chiefDept
cursor.execute(
"update sco_prefs set name = 'bul_show_sig_right' where name = 'bul_show_chiefDept'"
)
2020-09-26 16:19:37 +02:00
# cursor.execute("insert into sco_prefs (name, value, formsemestre_id) select 'bul_show_sig_left', value, formsemestre_id from sco_prefs where name = 'bul_show_sig_right'")
# date et lieu naissance (pour IFAG Sofia)
check_field(
cnx,
"identite",
"date_naissance",
[
"alter table identite add column date_naissance date",
"update identite set date_naissance=to_date(to_char( annee_naissance, 'FM9999') || '-01-01', 'YYYY-MM-DD')",
"alter table identite drop column annee_naissance",
],
)
check_field(
cnx,
"identite",
"lieu_naissance",
["alter table identite add column lieu_naissance text"],
)
2020-09-26 16:19:37 +02:00
# justification billets:
check_field(
cnx,
"billet_absence",
"justified",
[
"alter table billet_absence add column justified integer default 0",
"update billet_absence set justified=0",
],
)
2020-09-26 16:19:37 +02:00
# ----------------------- New groups
# 1- Create new tables
check_table(
cnx,
"partition",
[
2020-09-26 16:19:37 +02:00
"""CREATE TABLE partition(
partition_id text default notes_newid2('P') PRIMARY KEY,
formsemestre_id text REFERENCES notes_formsemestre(formsemestre_id),
partition_name text, -- "TD", "TP", ...
compute_ranks integer default 1, -- calcul rang etudiants dans les groupes
numero SERIAL, -- ordre de presentation
UNIQUE(formsemestre_id,partition_name)
) WITH OIDS;
"""
],
)
check_table(
cnx,
"group_descr",
[
2020-09-26 16:19:37 +02:00
"""CREATE TABLE group_descr (
group_id text default notes_newid2('G') PRIMARY KEY,
partition_id text REFERENCES partition(partition_id),
group_name text, -- "A", "C2", ...
UNIQUE(partition_id, group_name)
) WITH OIDS;
"""
],
)
check_table(
cnx,
"group_membership",
[
2020-09-26 16:19:37 +02:00
"""CREATE TABLE group_membership(
group_membership_id text default notes_newid2('GM') PRIMARY KEY,
etudid text REFERENCES identite(etudid),
group_id text REFERENCES group_descr(group_id),
UNIQUE(etudid, group_id)
) WITH OIDS;
"""
],
)
2020-09-26 16:19:37 +02:00
# 2- For each sem, create 1 to 4 partitions: all, TD (if any), TP, TA
# Here we have to deal with plain SQL, nasty...
if field_exists(cnx, "notes_formsemestre_inscription", "groupetd"):
2020-09-26 16:19:37 +02:00
# Some very old stduents didn't have addresses: it's now mandatory
cursor.execute(
"insert into adresse (etudid) select etudid from identite i except select etudid from adresse"
)
2020-09-26 16:19:37 +02:00
#
cursor.execute("SELECT formsemestre_id from notes_formsemestre")
formsemestre_ids = [x[0] for x in cursor.fetchall()]
2020-09-26 16:19:37 +02:00
for formsemestre_id in formsemestre_ids:
# create "all" partition (with empty name)
cursor.execute(
"INSERT into partition (formsemestre_id, compute_ranks) VALUES (%(formsemestre_id)s, 1)",
{"formsemestre_id": formsemestre_id},
)
cursor.execute(
"select partition_id from partition where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
partition_id = cursor.fetchone()[0]
# create group "all" (without name)
cursor.execute(
"INSERT into group_descr (partition_id) VALUES (%(pid)s)",
{"pid": partition_id},
)
cursor.execute(
"SELECT group_id from group_descr where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
group_id = cursor.fetchone()[0]
# inscrit etudiants:
cursor.execute(
"INSERT into group_membership (etudid, group_id) SELECT etudid, %(group_id)s from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s",
{"group_id": group_id, "formsemestre_id": formsemestre_id},
)
2020-09-26 16:19:37 +02:00
# create TD, TP, TA
cursor.execute(
"SELECT distinct(groupetd) from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s",
{"formsemestre_id": formsemestre_id},
)
groupetds = [x[0] for x in cursor.fetchall() if x[0]]
if len(groupetds) > 1 or (len(groupetds) == 1 and groupetds[0] != "A"):
2020-09-26 16:19:37 +02:00
# TD : create partition
cursor.execute(
"SELECT * from notes_formsemestre where formsemestre_id=%(formsemestre_id)s",
{"formsemestre_id": formsemestre_id},
)
nomgroupetd = cursor.dictfetchone()["nomgroupetd"]
if (
not nomgroupetd
): # pas de nom ??? on invente un nom stupide et unique
nomgroupetd = "TD_" + str(time.time()).replace(".", "")[-3:]
cursor.execute(
"INSERT into partition (formsemestre_id, partition_name) VALUES (%(formsemestre_id)s,%(nomgroupetd)s)",
{"formsemestre_id": formsemestre_id, "nomgroupetd": nomgroupetd},
)
cursor.execute(
"select partition_id from partition where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
partition_id = cursor.fetchone()[0]
# create groups
for groupetd in groupetds:
cursor.execute(
"INSERT into group_descr (partition_id, group_name) VALUES (%(pid)s, %(group_name)s)",
{"pid": partition_id, "group_name": groupetd},
)
cursor.execute(
"SELECT group_id from group_descr where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
group_id = cursor.fetchone()[0]
# inscrit les etudiants
cursor.execute(
"INSERT into group_membership (etudid, group_id) SELECT etudid, %(group_id)s from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s and groupetd=%(groupetd)s",
{
"group_id": group_id,
"formsemestre_id": formsemestre_id,
"groupetd": groupetd,
},
)
2020-09-26 16:19:37 +02:00
# TA
cursor.execute(
"SELECT distinct(groupeanglais) from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s",
{"formsemestre_id": formsemestre_id},
)
groupetds = [x[0] for x in cursor.fetchall() if x[0]]
2020-09-26 16:19:37 +02:00
if len(groupetds) > 0:
# TA : create partition
cursor.execute(
"SELECT * from notes_formsemestre where formsemestre_id=%(formsemestre_id)s",
{"formsemestre_id": formsemestre_id},
)
nomgroupetd = cursor.dictfetchone()["nomgroupeta"]
if (
not nomgroupetd
): # pas de nom ??? on invente un nom stupide et unique
nomgroupetd = "TA_" + str(time.time()).replace(".", "")[-3:]
cursor.execute(
"INSERT into partition (formsemestre_id, partition_name) VALUES (%(formsemestre_id)s,%(nomgroupeta)s)",
{"formsemestre_id": formsemestre_id, "nomgroupeta": nomgroupetd},
)
cursor.execute(
"select partition_id from partition where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
partition_id = cursor.fetchone()[0]
# create groups
for groupetd in groupetds:
cursor.execute(
"INSERT into group_descr (partition_id, group_name) VALUES (%(pid)s, %(group_name)s)",
{"pid": partition_id, "group_name": groupetd},
)
cursor.execute(
"SELECT group_id from group_descr where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
group_id = cursor.fetchone()[0]
# inscrit les etudiants
cursor.execute(
"INSERT into group_membership (etudid, group_id) SELECT etudid, %(group_id)s from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s and groupeanglais=%(groupetd)s",
{
"group_id": group_id,
"formsemestre_id": formsemestre_id,
"groupetd": groupetd,
},
)
2020-09-26 16:19:37 +02:00
# TP
cursor.execute(
"SELECT distinct(groupetp) from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s",
{"formsemestre_id": formsemestre_id},
)
groupetds = [x[0] for x in cursor.fetchall() if x[0]]
2020-09-26 16:19:37 +02:00
if len(groupetds) > 0:
# TP : create partition
cursor.execute(
"SELECT * from notes_formsemestre where formsemestre_id=%(formsemestre_id)s",
{"formsemestre_id": formsemestre_id},
)
nomgroupetd = cursor.dictfetchone()["nomgroupetp"]
if (
not nomgroupetd
): # pas de nom ??? on invente un nom stupide et unique
nomgroupetd = "TP_" + str(time.time()).replace(".", "")[-3:]
cursor.execute(
"INSERT into partition (formsemestre_id, partition_name) VALUES (%(formsemestre_id)s,%(nomgroupeta)s)",
{"formsemestre_id": formsemestre_id, "nomgroupeta": nomgroupetd},
)
cursor.execute(
"select partition_id from partition where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
partition_id = cursor.fetchone()[0]
# create groups
for groupetd in groupetds:
cursor.execute(
"INSERT into group_descr (partition_id, group_name) VALUES (%(pid)s, %(group_name)s)",
{"pid": partition_id, "group_name": groupetd},
)
cursor.execute(
"SELECT group_id from group_descr where oid=%(oid)s",
{"oid": cursor.lastoid()},
)
2020-09-26 16:19:37 +02:00
group_id = cursor.fetchone()[0]
# inscrit les etudiants
cursor.execute(
"INSERT into group_membership (etudid, group_id) SELECT etudid, %(group_id)s from notes_formsemestre_inscription where formsemestre_id=%(formsemestre_id)s and groupetp=%(groupetd)s",
{
"group_id": group_id,
"formsemestre_id": formsemestre_id,
"groupetd": groupetd,
},
)
2020-09-26 16:19:37 +02:00
# 3- Suppress obsolete fields
cursor.execute("""alter table notes_formsemestre drop column nomgroupetd""")
cursor.execute("""alter table notes_formsemestre drop column nomgroupetp""")
cursor.execute("""alter table notes_formsemestre drop column nomgroupeta""")
cursor.execute(
"""alter table notes_formsemestre_inscription drop column groupetd"""
)
cursor.execute(
"""alter table notes_formsemestre_inscription drop column groupetp"""
)
cursor.execute(
"""alter table notes_formsemestre_inscription drop column groupeanglais"""
)
2020-09-26 16:19:37 +02:00
# ----------------------- /New groups
# Add moy_ue to validations:
check_field(
cnx,
"scolar_formsemestre_validation",
"moy_ue",
[
"alter table scolar_formsemestre_validation add column moy_ue real",
],
)
2020-09-26 16:19:37 +02:00
# Add photo_filename
check_field(
cnx,
"identite",
"photo_filename",
[
"alter table identite add column photo_filename text",
],
)
2020-09-26 16:19:37 +02:00
# Add module's ECTS
check_field(
cnx,
"notes_modules",
"ects",
[
"alter table notes_modules add column ects real",
],
)
2020-09-26 16:19:37 +02:00
# Add "statut" to identite (default to NULL)
check_field(
cnx,
"identite",
"statut",
[
"alter table identite add column statut text",
],
)
2020-09-26 16:19:37 +02:00
# Add user-defined expressions
check_field(
cnx,
"notes_moduleimpl",
"computation_expr",
["alter table notes_moduleimpl add column computation_expr text"],
)
2020-09-26 16:19:37 +02:00
# Add semestre_id to scolar_formsemestre_validation
check_field(
cnx,
"scolar_formsemestre_validation",
"semestre_id",
["alter table scolar_formsemestre_validation add column semestre_id int"],
)
2020-09-26 16:19:37 +02:00
# Add
check_table(
cnx,
"absences_notifications",
[
"""
2020-09-26 16:19:37 +02:00
CREATE TABLE absences_notifications (
etudid text NOT NULL,
notification_date timestamp with time zone DEFAULT now(),
email text NOT NULL,
nbabs integer,
nbabsjust integer
) WITH OIDS;
"""
],
)
2020-09-26 16:19:37 +02:00
# rename old preference "send_mail_absence_to_chef"
cursor.execute(
"update sco_prefs set name = 'abs_notify_chief' where name = 'send_mail_absence_to_chef'"
)
check_table(
cnx,
"notes_formsemestre_ue_computation_expr",
[
"""
2020-09-26 16:19:37 +02:00
CREATE TABLE notes_formsemestre_ue_computation_expr (
notes_formsemestre_ue_computation_expr_id text default notes_newid('UEXPR') PRIMARY KEY,
formsemestre_id text REFERENCES notes_formsemestre(formsemestre_id),
ue_id text REFERENCES notes_ue(ue_id),
computation_expr text, -- formule de calcul moyenne
UNIQUE(formsemestre_id, ue_id)
) WITH OIDS;
"""
],
)
2020-09-26 16:19:37 +02:00
# add moduleimpl_id to absences:
check_field(
cnx,
"absences",
"moduleimpl_id",
["alter table absences add column moduleimpl_id text"],
)
2020-09-26 16:19:37 +02:00
# add type_parcours
check_field(
cnx,
"notes_formations",
"type_parcours",
[
"alter table notes_formations add column type_parcours int DEFAULT 0",
"update notes_formations set type_parcours=0 where type_parcours is NULL",
],
)
2020-09-26 16:19:37 +02:00
# add publish_incomplete
check_field(
cnx,
"notes_evaluation",
"publish_incomplete",
[
"alter table notes_evaluation add column publish_incomplete int DEFAULT 0",
"update notes_evaluation set publish_incomplete=0 where publish_incomplete is NULL",
],
)
2020-09-26 16:19:37 +02:00
# add ens_can_create_eval to notes_formsemestre:
check_field(
cnx,
"notes_formsemestre",
"ens_can_edit_eval",
[
"alter table notes_formsemestre add column ens_can_edit_eval int default 0",
"update notes_formsemestre set ens_can_edit_eval=0",
],
)
2020-09-26 16:19:37 +02:00
# add evaluation_type
check_field(
cnx,
"notes_evaluation",
"evaluation_type",
[
"alter table notes_evaluation add column evaluation_type int DEFAULT 0",
"update notes_evaluation set evaluation_type=0 where evaluation_type is NULL",
],
)
2020-09-26 16:19:37 +02:00
# add partition rank on bulletins
check_field(
cnx,
"partition",
"bul_show_rank",
[
"alter table partition add column bul_show_rank int DEFAULT 0",
"update partition set bul_show_rank=0 where bul_show_rank is NULL",
],
)
2020-09-26 16:19:37 +02:00
# add formsemestre to abs notifications
check_field(
cnx,
"absences_notifications",
"formsemestre_id",
[
"alter table absences_notifications add column formsemestre_id text DEFAULT NULL",
],
)
2020-09-26 16:19:37 +02:00
# Add "debouche" to admission
check_field(
cnx,
"admissions",
"debouche",
[
"alter table admissions add column debouche text DEFAULT NULL",
# et en profite pour corrige le From par defaut des mails:
"update sco_prefs set value='noreply@univ-paris13.fr' where name='email_from_addr' and value='noreply'",
],
)
2020-09-26 16:19:37 +02:00
# Increase semestre indices
for i in range(5, 9):
cursor.execute(
"SELECT * from notes_semestres where semestre_id=%(i)s", {"i": i}
)
2020-09-26 16:19:37 +02:00
r = cursor.fetchall()
if not r:
log("adding semestre_id %s" % i)
cursor.execute(
"INSERT INTO notes_semestres (semestre_id) VALUES (%(i)s)", {"i": i}
)
2020-09-26 16:19:37 +02:00
# ECTS associes aux UE:
check_field(
cnx,
"notes_ue",
"ects",
[
"alter table notes_ue add column ects float DEFAULT NULL",
],
)
2020-09-26 16:19:37 +02:00
# Numeros des evaluations:
check_field(
cnx,
"notes_evaluation",
"numero",
[
"alter table notes_evaluation add column numero int DEFAULT 0",
],
)
2020-09-26 16:19:37 +02:00
# add nom_usuel to identite
check_field(
cnx,
"identite",
"nom_usuel",
[
"alter table identite add column nom_usuel text DEFAULT NULL",
],
)
2020-09-26 16:19:37 +02:00
# add type_admission
check_field(
cnx,
"admissions",
"type_admission",
[
"alter table admissions add column type_admission text DEFAULT NULL",
],
)
check_field(
cnx,
"admissions",
"boursier_prec",
[
"alter table admissions add column boursier_prec integer default NULL",
],
)
2020-09-26 16:19:37 +02:00
# add modalites formation
check_table(
cnx,
"notes_form_modalites",
[
"""CREATE TABLE notes_form_modalites (
2020-09-26 16:19:37 +02:00
form_modalite_id text default notes_newid('Md') PRIMARY KEY,
modalite text, -- la clef dans notes_formsemestre
titre text, -- le nom complet de la modalite pour les documents scodoc
numero SERIAL -- integer, ordre de presentation
);""",
"""INSERT INTO notes_form_modalites (modalite, titre) VALUES ('', 'Autres formations');""",
"""INSERT INTO notes_form_modalites (modalite, titre) VALUES ('FI', 'Formation Initiale');""",
"""INSERT INTO notes_form_modalites (modalite, titre) VALUES ('FC', 'Formation Continue');""",
"""INSERT INTO notes_form_modalites (modalite, titre) VALUES ('FAP', 'Apprentissage');""",
"""INSERT INTO notes_form_modalites (modalite, titre) VALUES ('DEC', 'Formation Décalées');""",
"""INSERT INTO notes_form_modalites (modalite, titre) VALUES ('LIC', 'Licence');""",
],
)
2020-09-26 16:19:37 +02:00
# Add code_specialite
check_field(
cnx,
"notes_formations",
"code_specialite",
[
"alter table notes_formations add column code_specialite text default NULL",
],
)
2020-09-26 16:19:37 +02:00
# Fix modules without codes
cursor.execute(
"UPDATE notes_modules SET code = 'M_' || coalesce(upper(substring(titre from 1 for 2)), '') || '_' || coalesce(semestre_id,'0') where code is NULL;"
)
2020-09-26 16:19:37 +02:00
# Add ue.is_external
check_field(
cnx,
"notes_ue",
"is_external",
[
"alter table notes_ue add column is_external integer default 0",
],
)
check_field(
cnx,
"scolar_formsemestre_validation",
"is_external",
[
"alter table scolar_formsemestre_validation add column is_external integer default 0",
],
)
2020-09-26 16:19:37 +02:00
# Add codes apogee
check_field(
cnx,
"notes_ue",
"code_apogee",
[
"alter table notes_ue add column code_apogee text UNIQUE",
],
)
check_field(
cnx,
"notes_modules",
"code_apogee",
[
"alter table notes_modules add column code_apogee text UNIQUE",
],
)
check_field(
cnx,
"notes_formsemestre",
"elt_sem_apo",
[
"alter table notes_formsemestre add column elt_sem_apo text",
],
)
check_field(
cnx,
"notes_formsemestre",
"elt_annee_apo",
[
"alter table notes_formsemestre add column elt_annee_apo text",
],
)
2020-09-26 16:19:37 +02:00
# Classement admission
check_field(
cnx,
"admissions",
"classement",
[
"alter table admissions add column classement integer default NULL",
],
)
2020-09-26 16:19:37 +02:00
# Supprime contraintes erronées sur codes Apogee:
if list_constraint(cnx, constraint_name="notes_ue_code_apogee_key"):
log("dropping buggy constraint on notes_ue_code_apogee")
cursor.execute(
"alter table notes_ue drop CONSTRAINT notes_ue_code_apogee_key;"
)
if list_constraint(cnx, constraint_name="notes_modules_code_apogee_key"):
log("dropping buggy constraint on notes_modules_code_apogee")
cursor.execute(
"alter table notes_modules drop CONSTRAINT notes_modules_code_apogee_key;"
)
2020-09-26 16:19:37 +02:00
# SemSet:
check_table(
cnx,
"notes_semset",
[
"""CREATE TABLE notes_semset (
2020-09-26 16:19:37 +02:00
semset_id text default notes_newid('NSS') PRIMARY KEY,
title text,
annee_scolaire int default NULL, -- 2016
sem_id int default NULL -- 0, 1, 2
) WITH OIDS;""",
],
)
check_field(
cnx,
"notes_semset",
"annee_scolaire",
[
"alter table notes_semset add column annee_scolaire integer default NULL",
],
)
check_table(
cnx,
"notes_semset_formsemestre",
[
"""CREATE TABLE notes_semset_formsemestre (
2020-09-26 16:19:37 +02:00
formsemestre_id text REFERENCES notes_formsemestre(formsemestre_id) ON DELETE CASCADE,
semset_id text REFERENCES notes_semset (semset_id) ON DELETE CASCADE,
PRIMARY KEY (formsemestre_id, semset_id)
) WITH OIDS;""",
],
)
2020-09-26 16:19:37 +02:00
# ModuleTags
check_table(
cnx,
"notes_tags",
[
"""CREATE TABLE notes_tags (
2020-09-26 16:19:37 +02:00
tag_id text default notes_newid('TAG') PRIMARY KEY,
title text UNIQUE NOT NULL
) WITH OIDS;""",
],
)
check_table(
cnx,
"notes_modules_tags",
[
"""CREATE TABLE notes_modules_tags (
2020-09-26 16:19:37 +02:00
tag_id text REFERENCES notes_tags(tag_id) ON DELETE CASCADE,
module_id text REFERENCES notes_modules(module_id) ON DELETE CASCADE,
PRIMARY KEY (tag_id, module_id)
) WITH OIDS;""",
],
)
2020-09-26 16:19:37 +02:00
# add show_in_lists on partition
check_field(
cnx,
"partition",
"show_in_lists",
[
"alter table partition add column show_in_lists integer DEFAULT 1",
"update partition set show_in_lists=1 where show_in_lists is NULL",
],
)
2020-09-26 16:19:37 +02:00
# table codes etapes apogee semestre
check_table(
cnx,
"notes_formsemestre_etapes",
[
"""CREATE TABLE notes_formsemestre_etapes (
2020-09-26 16:19:37 +02:00
formsemestre_id text REFERENCES notes_formsemestre(formsemestre_id) ON DELETE CASCADE,
etape_apo text NOT NULL
) WITH OIDS;""",
"""INSERT into notes_formsemestre_etapes (formsemestre_id, etape_apo) SELECT formsemestre_id, etape_apo FROM notes_formsemestre WHERE etape_apo is not NULL;""",
"""INSERT into notes_formsemestre_etapes (formsemestre_id, etape_apo) SELECT formsemestre_id, etape_apo2 FROM notes_formsemestre WHERE etape_apo2 is not NULL;""",
"""INSERT into notes_formsemestre_etapes (formsemestre_id, etape_apo) SELECT formsemestre_id, etape_apo3 FROM notes_formsemestre WHERE etape_apo3 is not NULL;""",
"""INSERT into notes_formsemestre_etapes (formsemestre_id, etape_apo) SELECT formsemestre_id, etape_apo4 FROM notes_formsemestre WHERE etape_apo4 is not NULL;""",
"""ALTER table notes_formsemestre DROP column etape_apo;""",
"""ALTER table notes_formsemestre DROP column etape_apo2;""",
"""ALTER table notes_formsemestre DROP column etape_apo3;""",
"""ALTER table notes_formsemestre DROP column etape_apo4;""",
],
)
2020-09-26 16:19:37 +02:00
# Admission APB: groupe et classement dans groupe
check_field(
cnx,
"admissions",
"apb_groupe",
[
"alter table admissions add column apb_groupe text default NULL",
],
)
check_field(
cnx,
"admissions",
"apb_classement_gr",
[
"alter table admissions add column apb_classement_gr integer default NULL",
],
)
2020-09-26 16:19:37 +02:00
# Adresse mail perso
check_field(
cnx,
"adresse",
"emailperso",
[
"alter table adresse add column emailperso text",
],
)
# Ajout de modalites supplementaires
2020-09-26 16:19:37 +02:00
cursor.execute("SELECT modalite from notes_form_modalites where modalite= 'CP'")
if not len(cursor.fetchall()):
log('adding modalite "CP"')
cursor.execute(
"INSERT INTO notes_form_modalites (modalite, titre) VALUES ('CP', 'Contrats de Professionnalisation');"
)
2020-09-26 16:19:37 +02:00
# Un index oublié sur notes_notes:
if "notes_notes_evaluation_id_idx" not in list_table_index(cnx, "notes_notes"):
log("creating index on notes_notes")
cursor.execute(
"CREATE INDEX notes_notes_evaluation_id_idx ON notes_notes (evaluation_id)"
)
2020-09-26 16:19:37 +02:00
# boursier (ajout API nov 2017)
check_field(
cnx, "identite", "boursier", ["alter table identite add column boursier text"]
)
2020-09-26 16:19:37 +02:00
# Suivi des anciens etudiants (debouche)
# cree table suivi et recopie ancien champs debouche de la table admission
check_table(
cnx,
"itemsuivi",
[
"""CREATE TABLE itemsuivi (
2020-09-26 16:19:37 +02:00
itemsuivi_id text DEFAULT notes_newid('SUI'::text) PRIMARY KEY,
etudid text NOT NULL,
item_date date DEFAULT now(),
situation text
) WITH OIDS;""",
"""INSERT INTO itemsuivi (etudid, situation)
2020-09-26 16:19:37 +02:00
SELECT etudid, debouche FROM admissions WHERE debouche is not null;
""",
],
)
check_table(
cnx,
"itemsuivi_tags",
[
"""CREATE TABLE itemsuivi_tags (
2020-09-26 16:19:37 +02:00
tag_id text default notes_newid('TG') PRIMARY KEY,
title text UNIQUE NOT NULL
) WITH OIDS;""",
],
)
check_table(
cnx,
"itemsuivi_tags_assoc",
[
"""CREATE TABLE itemsuivi_tags_assoc (
2020-09-26 16:19:37 +02:00
tag_id text REFERENCES itemsuivi_tags(tag_id) ON DELETE CASCADE,
itemsuivi_id text REFERENCES itemsuivi(itemsuivi_id) ON DELETE CASCADE,
PRIMARY KEY (tag_id, itemsuivi_id)
) WITH OIDS;""",
],
)
2020-09-26 16:19:37 +02:00
# Types de modules (pour malus)
check_field(
cnx,
"notes_modules",
"module_type",
[
"alter table notes_modules add column module_type int",
],
)
2020-09-26 16:19:37 +02:00
# Responsables de semestres
check_table(
cnx,
"notes_formsemestre_responsables",
[
"""CREATE TABLE notes_formsemestre_responsables (
2020-09-26 16:19:37 +02:00
formsemestre_id text REFERENCES notes_formsemestre(formsemestre_id) ON DELETE CASCADE,
responsable_id text NOT NULL,
UNIQUE(formsemestre_id, responsable_id)
) WITH OIDS;""",
"""INSERT into notes_formsemestre_responsables (formsemestre_id, responsable_id) SELECT formsemestre_id, responsable_id FROM notes_formsemestre WHERE responsable_id is not NULL;""",
"""ALTER table notes_formsemestre DROP column responsable_id;""",
],
)
2020-09-26 16:19:37 +02:00
# Fonction pour anonymisation:
if not function_exists(cnx, "random_text_md5"):
log("creating function random_text_md5")
2020-09-26 16:19:37 +02:00
# inspirée par https://www.simononsoftware.com/random-string-in-postgresql/
cursor.execute(
"""CREATE FUNCTION random_text_md5( integer ) returns text
2020-09-26 16:19:37 +02:00
LANGUAGE SQL
AS $$
select upper( substring( (SELECT string_agg(md5(random()::TEXT), '')
FROM generate_series(
1,
CEIL($1 / 32.)::integer)
), 1, $1) );
$$;"""
)
2020-09-26 16:19:37 +02:00
# departement naissance (ajout fev 2020)
check_field(
cnx,
"identite",
"dept_naissance",
["alter table identite add column dept_naissance text"],
)
2020-09-26 16:19:37 +02:00
# Modalite semestres exterieurs
cursor.execute("SELECT modalite from notes_form_modalites where modalite= 'EXT'")
if not len(cursor.fetchall()):
log('adding modalite "EXT"')
cursor.execute(
"INSERT INTO notes_form_modalites (modalite, titre) VALUES ('EXT', 'Extérieur');"
)
2020-09-26 16:19:37 +02:00
# Coefficients d'UE
check_field(
cnx,
"notes_ue",
"coefficient",
[
"alter table notes_ue add column coefficient float",
# Initialise les coefficients égaux aux ECTS:
"update notes_ue set coefficient=ects",
# Force pref locale sur semestres existants:
"""INSERT INTO sco_prefs (name, value, formsemestre_id)
2020-09-26 16:19:37 +02:00
SELECT DISTINCT 'use_ue_coefs', '0', formsemestre_id FROM notes_formsemestre
ON CONFLICT DO NOTHING
""",
],
)
# Etape d'inscription
check_field(
cnx,
"notes_formsemestre_inscription",
"etape",
["alter table notes_formsemestre_inscription add column etape text"],
)
# Migre identite.sexe vers identite.civilite: normalise valeurs: M, F, X
check_field(
cnx,
"identite",
"civilite",
[
"UPDATE identite set sexe='M' where upper(sexe) = 'M' or upper(sexe) = 'M.' or upper(sexe) = 'MR' or upper(sexe) = 'H'",
"UPDATE identite set sexe='F' where upper(sexe) = 'F' or upper(sexe) = 'MME' or upper(sexe) = 'MLLE' or upper(sexe) = 'MELLE' or upper(sexe) = 'MLLE.' or upper(sexe) = 'F'",
"UPDATE identite set sexe='X' where sexe is NULL",
"ALTER TABLE identite RENAME COLUMN sexe TO civilite",
"ALTER TABLE identite ALTER COLUMN civilite SET NOT NULL",
"ALTER TABLE identite ADD CONSTRAINT civchk CHECK (civilite IN ('M', 'F', 'X'))",
],
)
2020-09-26 16:19:37 +02:00
# Add here actions to performs after upgrades:
cnx.commit()
cnx.close()
# Base utilisateurs:
log("\nChecking users database")
cnx = psycopg2.connect(get_users_cnx_str())
2020-09-26 16:19:37 +02:00
cursor = cnx.cursor()
check_field(
cnx,
"sco_users",
"passwd_temp",
[
"alter table sco_users add column passwd_temp int default 0",
"update sco_users set passwd_temp=0",
],
)
check_field(
cnx,
"sco_users",
"status",
["alter table sco_users add column status text default NULL"],
)
check_field(
cnx,
"sco_users",
"date_expiration",
[
"alter table sco_users add column date_expiration date",
"update sco_users set status=NULL where status=''", # fix a bug in previous update...
],
)
check_field(
cnx,
"sco_users",
"login_edt",
[
"alter table sco_users add column login_edt text default NULL",
],
)
2020-09-26 16:19:37 +02:00
cnx.commit()
cnx.close()
# The end.
sys.exit(0)