IDK/ScoDoc
1
0
Fork 0
forked from ScoDoc/ScoDoc
Code Issues Pull Requests Projects Releases Wiki Activity
442e1a35c9
ScoDoc/app/entreprises/routes.py

1008 lines
36 KiB
Python
Raw Blame History

import os
from config import Config
from datetime import datetime, date
import glob
import shutil
from flask import render_template, redirect, url_for, request, flash, send_file, abort
from flask.json import jsonify
from flask_login import current_user
from app.decorators import permission_required
from app.entreprises import LOGS_LEN
from app.entreprises.forms import (
EntrepriseCreationForm,
EntrepriseModificationForm,
SuppressionConfirmationForm,
OffreCreationForm,
OffreModificationForm,
ContactCreationForm,
ContactModificationForm,
HistoriqueCreationForm,
EnvoiOffreForm,
AjoutFichierForm,
ValidationConfirmationForm,
ImportEntreprisesForm,
)
from app.entreprises import bp
from app.entreprises.models import (
Entreprise,
EntrepriseOffre,
EntrepriseContact,
EntrepriseLog,
EntrepriseEtudiant,
EntrepriseEnvoiOffre,
EntrepriseOffreDepartement,
)
from app.models import Identite
from app.auth.models import User
from app.scodoc.sco_permissions import Permission
from app.scodoc import sco_etud, sco_excel
import app.scodoc.sco_utils as scu
from app import db
from sqlalchemy import text
from werkzeug.utils import secure_filename
@bp.route("/", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesView)
def index():
"""
Permet d'afficher une page avec la liste des entreprises et une liste des dernières opérations
"""
page = request.args.get("page", 1, type=int)
entreprises = Entreprise.query.filter_by(visible=True).paginate(
page=page, per_page=10
)
logs = EntrepriseLog.query.order_by(EntrepriseLog.date.desc()).limit(LOGS_LEN).all()
return render_template(
"entreprises/entreprises.html",
title=("Entreprises"),
entreprises=entreprises,
logs=logs,
)
@bp.route("/logs", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesView)
def logs():
"""
Permet d'afficher les logs (toutes les entreprises)
"""
page = request.args.get("page", 1, type=int)
logs = EntrepriseLog.query.order_by(EntrepriseLog.date.desc()).paginate(
page=page, per_page=20
)
return render_template("entreprises/logs.html", title=("Logs"), logs=logs)
@bp.route("/validation", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesValidate)
def validation():
"""
Permet d'afficher une page avec la liste des entreprises a valider
"""
entreprises = Entreprise.query.filter_by(visible=False).all()
return render_template(
"entreprises/entreprises_validation.html",
title=("Validation entreprises"),
entreprises=entreprises,
)
@bp.route("/contacts", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesView)
def contacts():
"""
Permet d'afficher une page la liste des contacts et une liste des dernières opérations
"""
page = request.args.get("page", 1, type=int)
contacts = (
db.session.query(EntrepriseContact, Entreprise)
.join(Entreprise, EntrepriseContact.entreprise_id == Entreprise.id)
.filter_by(visible=True)
.paginate(page=page, per_page=10)
)
logs = EntrepriseLog.query.order_by(EntrepriseLog.date.desc()).limit(LOGS_LEN).all()
return render_template(
"entreprises/contacts.html", title=("Contacts"), contacts=contacts, logs=logs
)
@bp.route("/fiche_entreprise/<int:id>", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesView)
def fiche_entreprise(id):
"""
Permet d'afficher la fiche entreprise d'une entreprise avec une liste des dernières opérations et
l'historique des étudiants ayant réaliser un stage ou une alternance dans cette entreprise.
La fiche entreprise comporte les informations de l'entreprise, les contacts de l'entreprise et
les offres de l'entreprise.
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
offres = entreprise.offres
offres_with_files = []
for offre in offres:
if date.today() > offre.expiration_date:
break
files = []
path = os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{offre.entreprise_id}",
f"{offre.id}",
)
if os.path.exists(path):
for dir in glob.glob(
f"{path}/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"
):
for file in glob.glob(f"{dir}/*"):
file = [os.path.basename(dir), os.path.basename(file)]
files.append(file)
offre_depts = EntrepriseOffreDepartement.query.filter_by(
offre_id=offre.id
).all()
offres_with_files.append([offre, files, offre_depts])
contacts = entreprise.contacts
logs = (
EntrepriseLog.query.order_by(EntrepriseLog.date.desc())
.filter_by(object=id)
.limit(LOGS_LEN)
.all()
)
historique = (
db.session.query(EntrepriseEtudiant, Identite)
.order_by(EntrepriseEtudiant.date_debut.desc())
.filter(EntrepriseEtudiant.entreprise_id == id)
.join(Identite, Identite.id == EntrepriseEtudiant.etudid)
.all()
)
return render_template(
"entreprises/fiche_entreprise.html",
title=("Fiche entreprise"),
entreprise=entreprise,
contacts=contacts,
offres=offres_with_files,
logs=logs,
historique=historique,
)
@bp.route("/logs/<int:id>", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesView)
def logs_entreprise(id):
"""
Permet d'afficher les logs (toutes les entreprises)
"""
page = request.args.get("page", 1, type=int)
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
logs = (
EntrepriseLog.query.order_by(EntrepriseLog.date.desc())
.filter_by(object=id)
.paginate(page=page, per_page=20)
)
return render_template(
"entreprises/logs_entreprise.html",
title=("Logs"),
logs=logs,
entreprise=entreprise,
)
@bp.route("/fiche_entreprise_validation/<int:id>", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesValidate)
def fiche_entreprise_validation(id):
"""
Permet d'afficher la fiche entreprise d'une entreprise a valider
"""
entreprise = Entreprise.query.filter_by(id=id, visible=False).first_or_404()
contacts = entreprise.contacts
return render_template(
"entreprises/fiche_entreprise_validation.html",
title=("Validation fiche entreprise"),
entreprise=entreprise,
contacts=contacts,
)
@bp.route("/offres_recues", methods=["GET"])
@permission_required(Permission.RelationsEntreprisesView)
def offres_recues():
"""
Permet d'afficher la page où l'on recoit les offres
"""
offres_recues = (
db.session.query(EntrepriseEnvoiOffre, EntrepriseOffre)
.filter(EntrepriseEnvoiOffre.receiver_id == current_user.id)
.join(EntrepriseOffre, EntrepriseOffre.id == EntrepriseEnvoiOffre.offre_id)
.all()
)
offres_recues_with_files = []
for offre in offres_recues:
files = []
path = os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{offre[1].entreprise_id}",
f"{offre[1].id}",
)
if os.path.exists(path):
for dir in glob.glob(
f"{path}/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"
):
for file in glob.glob(f"{dir}/*"):
file = [os.path.basename(dir), os.path.basename(file)]
files.append(file)
offres_recues_with_files.append([offre[0], offre[1], files])
return render_template(
"entreprises/offres_recues.html",
title=("Offres reçues"),
offres_recues=offres_recues_with_files,
)
@bp.route("/fiche_entreprise/<int:id>/offres_expirees")
@permission_required(Permission.RelationsEntreprisesView)
def offres_expirees(id):
"""
Permet d'afficher la liste des offres expirés d'une entreprise
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
offres = entreprise.offres
offres_expirees_with_files = []
for offre in offres:
if date.today() > offre.expiration_date:
files = []
path = os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{offre.entreprise_id}",
f"{offre.id}",
)
if os.path.exists(path):
for dir in glob.glob(
f"{path}/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"
):
for file in glob.glob(f"{dir}/*"):
file = [os.path.basename(dir), os.path.basename(file)]
files.append(file)
offre_depts = EntrepriseOffreDepartement.query.filter_by(
offre_id=offre.id
).all()
offres_expirees_with_files.append([offre, files, offre_depts])
return render_template(
"entreprises/offres_expirees.html",
title=("Offres expirées"),
entreprise=entreprise,
offres_expirees=offres_expirees_with_files,
)
@bp.route("/add_entreprise", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def add_entreprise():
"""
Permet d'ajouter une entreprise dans la base avec un formulaire
"""
form = EntrepriseCreationForm()
if form.validate_on_submit():
entreprise = Entreprise(
nom=form.nom_entreprise.data.strip(),
siret=form.siret.data.strip(),
adresse=form.adresse.data.strip(),
codepostal=form.codepostal.data.strip(),
ville=form.ville.data.strip(),
pays=form.pays.data.strip(),
)
db.session.add(entreprise)
db.session.commit()
db.session.refresh(entreprise)
contact = EntrepriseContact(
entreprise_id=entreprise.id,
nom=form.nom_contact.data.strip(),
prenom=form.prenom_contact.data.strip(),
telephone=form.telephone.data.strip(),
mail=form.mail.data.strip(),
poste=form.poste.data.strip(),
service=form.service.data.strip(),
)
db.session.add(contact)
if current_user.has_permission(Permission.RelationsEntreprisesValidate, None):
entreprise.visible = True
nom_entreprise = f"<a href=/ScoDoc/entreprises/fiche_entreprise/{entreprise.id}>{entreprise.nom}</a>"
log = EntrepriseLog(
authenticated_user=current_user.user_name,
text=f"{nom_entreprise} - Création de la fiche entreprise ({entreprise.nom}) avec un contact",
)
db.session.add(log)
db.session.commit()
flash("L'entreprise a été ajouté à la liste.")
return redirect(url_for("entreprises.index"))
else:
entreprise.visible = False
db.session.commit()
flash("L'entreprise a été ajouté à la liste pour la validation.")
return redirect(url_for("entreprises.index"))
return render_template(
"entreprises/ajout_entreprise.html",
title=("Ajout entreprise avec contact"),
form=form,
)
@bp.route("/edit_entreprise/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def edit_entreprise(id):
"""
Permet de modifier une entreprise de la base avec un formulaire
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
form = EntrepriseModificationForm()
if form.validate_on_submit():
nom_entreprise = f"<a href=/ScoDoc/entreprises/fiche_entreprise/{entreprise.id}>{form.nom.data.strip()}</a>"
if entreprise.nom != form.nom.data.strip():
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text=f"{nom_entreprise} - Modification du nom (ancien nom : {entreprise.nom})",
)
entreprise.nom = form.nom.data.strip()
db.session.add(log)
if entreprise.adresse != form.adresse.data.strip():
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text=f"{nom_entreprise} - Modification de l'adresse (ancienne adresse : {entreprise.adresse})",
)
entreprise.adresse = form.adresse.data.strip()
db.session.add(log)
if entreprise.codepostal != form.codepostal.data.strip():
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text=f"{nom_entreprise} - Modification du code postal (ancien code postal : {entreprise.codepostal})",
)
entreprise.codepostal = form.codepostal.data.strip()
db.session.add(log)
if entreprise.ville != form.ville.data.strip():
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text=f"{nom_entreprise} - Modification de la ville (ancienne ville : {entreprise.ville})",
)
entreprise.ville = form.ville.data.strip()
db.session.add(log)
if entreprise.pays != form.pays.data.strip():
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text=f"{nom_entreprise} - Modification du pays (ancien pays : {entreprise.pays})",
)
entreprise.pays = form.pays.data.strip()
db.session.add(log)
db.session.commit()
flash("L'entreprise a été modifié.")
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise.id))
elif request.method == "GET":
form.siret.data = entreprise.siret
form.nom.data = entreprise.nom
form.adresse.data = entreprise.adresse
form.codepostal.data = entreprise.codepostal
form.ville.data = entreprise.ville
form.pays.data = entreprise.pays
return render_template(
"entreprises/form.html", title=("Modification entreprise"), form=form
)
@bp.route("/delete_entreprise/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def delete_entreprise(id):
"""
Permet de supprimer une entreprise de la base avec un formulaire de confirmation
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
form = SuppressionConfirmationForm()
if form.validate_on_submit():
db.session.delete(entreprise)
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text=f"Suppression de la fiche entreprise ({entreprise.nom})",
)
db.session.add(log)
db.session.commit()
flash("L'entreprise a été supprimé de la liste.")
return redirect(url_for("entreprises.index"))
return render_template(
"entreprises/delete_confirmation.html",
title=("Supression entreprise"),
form=form,
)
@bp.route("/validate_entreprise/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesValidate)
def validate_entreprise(id):
"""
Permet de valider une entreprise
"""
form = ValidationConfirmationForm()
entreprise = Entreprise.query.filter_by(id=id, visible=False).first_or_404()
if form.validate_on_submit():
entreprise.visible = True
nom_entreprise = f"<a href=/ScoDoc/entreprises/fiche_entreprise/{entreprise.id}>{entreprise.nom}</a>"
log = EntrepriseLog(
authenticated_user=current_user.user_name,
text=f"{nom_entreprise} - Validation de la fiche entreprise ({entreprise.nom}) avec un contact",
)
db.session.add(log)
db.session.commit()
flash("L'entreprise a été validé et ajouté à la liste.")
return redirect(url_for("entreprises.index"))
return render_template(
"entreprises/validate_confirmation.html",
title=("Validation entreprise"),
form=form,
)
@bp.route("/add_offre/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def add_offre(id):
"""
Permet d'ajouter une offre a une entreprise
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
form = OffreCreationForm()
if form.validate_on_submit():
offre = EntrepriseOffre(
entreprise_id=entreprise.id,
intitule=form.intitule.data.strip(),
description=form.description.data.strip(),
type_offre=form.type_offre.data.strip(),
missions=form.missions.data.strip(),
duree=form.duree.data.strip(),
expiration_date=form.expiration_date.data,
)
db.session.add(offre)
db.session.commit()
db.session.refresh(offre)
for dept in form.depts.data:
offre_dept = EntrepriseOffreDepartement(
offre_id=offre.id,
dept_id=dept,
)
db.session.add(offre_dept)
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text="Création d'une offre",
)
db.session.add(log)
db.session.commit()
flash("L'offre a été ajouté à la fiche entreprise.")
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise.id))
return render_template("entreprises/form.html", title=("Ajout offre"), form=form)
@bp.route("/edit_offre/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def edit_offre(id):
"""
Permet de modifier une offre
"""
offre = EntrepriseOffre.query.filter_by(id=id).first_or_404()
offre_depts = EntrepriseOffreDepartement.query.filter_by(offre_id=offre.id).all()
form = OffreModificationForm()
offre_depts_list = [(offre_dept.dept_id) for offre_dept in offre_depts]
if form.validate_on_submit():
offre.intitule = form.intitule.data.strip()
offre.description = form.description.data.strip()
offre.type_offre = form.type_offre.data.strip()
offre.missions = form.missions.data.strip()
offre.duree = form.duree.data.strip()
offre.expiration_date = form.expiration_date.data
if offre_depts_list != form.depts.data:
for dept in form.depts.data:
if dept not in offre_depts_list:
offre_dept = EntrepriseOffreDepartement(
offre_id=offre.id,
dept_id=dept,
)
db.session.add(offre_dept)
for dept in offre_depts_list:
if dept not in form.depts.data:
offre_dept = EntrepriseOffreDepartement.query.filter_by(
offre_id=offre.id, dept_id=dept
).first_or_404()
db.session.delete(offre_dept)
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=offre.entreprise_id,
text="Modification d'une offre",
)
db.session.add(log)
db.session.commit()
flash("L'offre a été modifié.")
return redirect(url_for("entreprises.fiche_entreprise", id=offre.entreprise.id))
elif request.method == "GET":
form.intitule.data = offre.intitule
form.description.data = offre.description
form.type_offre.data = offre.type_offre
form.missions.data = offre.missions
form.duree.data = offre.duree
form.expiration_date.data = offre.expiration_date
form.depts.data = offre_depts_list
return render_template(
"entreprises/form.html", title=("Modification offre"), form=form
)
@bp.route("/delete_offre/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def delete_offre(id):
"""
Permet de supprimer une offre
"""
offre = EntrepriseOffre.query.filter_by(id=id).first_or_404()
entreprise_id = offre.entreprise.id
form = SuppressionConfirmationForm()
if form.validate_on_submit():
db.session.delete(offre)
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=offre.entreprise_id,
text="Suppression d'une offre",
)
db.session.add(log)
db.session.commit()
flash("L'offre a été supprimé de la fiche entreprise.")
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise_id))
return render_template(
"entreprises/delete_confirmation.html", title=("Supression offre"), form=form
)
@bp.route("/add_contact/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def add_contact(id):
"""
Permet d'ajouter un contact a une entreprise
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
form = ContactCreationForm(hidden_entreprise_id=entreprise.id)
if form.validate_on_submit():
contact = EntrepriseContact(
entreprise_id=entreprise.id,
nom=form.nom.data.strip(),
prenom=form.prenom.data.strip(),
telephone=form.telephone.data.strip(),
mail=form.mail.data.strip(),
poste=form.poste.data.strip(),
service=form.service.data.strip(),
)
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=entreprise.id,
text="Création d'un contact",
)
db.session.add(log)
db.session.add(contact)
db.session.commit()
flash("Le contact a été ajouté à la fiche entreprise.")
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise.id))
return render_template("entreprises/form.html", title=("Ajout contact"), form=form)
@bp.route("/edit_contact/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def edit_contact(id):
"""
Permet de modifier un contact
"""
contact = EntrepriseContact.query.filter_by(id=id).first_or_404()
form = ContactModificationForm(
hidden_entreprise_id=contact.entreprise_id,
hidden_contact_id=contact.id,
)
if form.validate_on_submit():
contact.nom = form.nom.data.strip()
contact.prenom = form.prenom.data.strip()
contact.telephone = form.telephone.data.strip()
contact.mail = form.mail.data.strip()
contact.poste = form.poste.data.strip()
contact.service = form.service.data.strip()
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=contact.entreprise_id,
text="Modification d'un contact",
)
db.session.add(log)
db.session.commit()
flash("Le contact a été modifié.")
return redirect(
url_for("entreprises.fiche_entreprise", id=contact.entreprise.id)
)
elif request.method == "GET":
form.nom.data = contact.nom
form.prenom.data = contact.prenom
form.telephone.data = contact.telephone
form.mail.data = contact.mail
form.poste.data = contact.poste
form.service.data = contact.service
return render_template(
"entreprises/form.html", title=("Modification contact"), form=form
)
@bp.route("/delete_contact/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def delete_contact(id):
"""
Permet de supprimer un contact
"""
contact = EntrepriseContact.query.filter_by(id=id).first_or_404()
entreprise_id = contact.entreprise.id
form = SuppressionConfirmationForm()
if form.validate_on_submit():
contact_count = EntrepriseContact.query.filter_by(
entreprise_id=contact.entreprise.id
).count()
if contact_count == 1:
flash(
"Le contact n'a pas été supprimé de la fiche entreprise. (1 contact minimum)"
)
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise_id))
else:
db.session.delete(contact)
log = EntrepriseLog(
authenticated_user=current_user.user_name,
object=contact.entreprise_id,
text="Suppression d'un contact",
)
db.session.add(log)
db.session.commit()
flash("Le contact a été supprimé de la fiche entreprise.")
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise_id))
return render_template(
"entreprises/delete_confirmation.html", title=("Supression contact"), form=form
)
@bp.route("/add_historique/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def add_historique(id):
"""
Permet d'ajouter un étudiant ayant réalisé un stage ou une alternance sur la fiche entreprise de l'entreprise
"""
entreprise = Entreprise.query.filter_by(id=id, visible=True).first_or_404()
form = HistoriqueCreationForm()
if form.validate_on_submit():
etudiant_nomcomplet = form.etudiant.data.upper().strip()
stm = text(
"SELECT id, CONCAT(nom, ' ', prenom) as nom_prenom FROM Identite WHERE CONCAT(nom, ' ', prenom)=:nom_prenom"
)
etudiant = (
Identite.query.from_statement(stm)
.params(nom_prenom=etudiant_nomcomplet)
.first()
)
formation = etudiant.inscription_courante_date(
form.date_debut.data, form.date_fin.data
)
historique = EntrepriseEtudiant(
entreprise_id=entreprise.id,
etudid=etudiant.id,
type_offre=form.type_offre.data.strip(),
date_debut=form.date_debut.data,
date_fin=form.date_fin.data,
formation_text=formation.formsemestre.titre if formation else None,
formation_scodoc=formation.formsemestre.formsemestre_id
if formation
else None,
)
db.session.add(historique)
db.session.commit()
flash("L'étudiant a été ajouté sur la fiche entreprise.")
return redirect(url_for("entreprises.fiche_entreprise", id=entreprise.id))
return render_template(
"entreprises/ajout_historique.html", title=("Ajout historique"), form=form
)
@bp.route("/envoyer_offre/<int:id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesSend)
def envoyer_offre(id):
"""
Permet d'envoyer une offre à un utilisateur
"""
offre = EntrepriseOffre.query.filter_by(id=id).first_or_404()
form = EnvoiOffreForm()
if form.validate_on_submit():
responsable_data = form.responsable.data.upper().strip()
stm = text(
"SELECT id, UPPER(CONCAT(nom, ' ', prenom, ' ', '(', user_name, ')')) FROM \"user\" WHERE UPPER(CONCAT(nom, ' ', prenom, ' ', '(', user_name, ')'))=:responsable_data"
)
responsable = (
User.query.from_statement(stm)
.params(responsable_data=responsable_data)
.first()
)
envoi_offre = EntrepriseEnvoiOffre(
sender_id=current_user.id, receiver_id=responsable.id, offre_id=offre.id
)
db.session.add(envoi_offre)
db.session.commit()
flash(f"L'offre a été envoyé à {responsable.get_nomplogin()}.")
return redirect(url_for("entreprises.fiche_entreprise", id=offre.entreprise_id))
return render_template(
"entreprises/envoi_offre_form.html", title=("Envoyer une offre"), form=form
)
@bp.route("/etudiants")
@permission_required(Permission.RelationsEntreprisesChange)
def json_etudiants():
"""
Permet de récuperer un JSON avec tous les étudiants
"""
if request.args.get("term") == None:
abort(400)
term = request.args.get("term").strip()
etudiants = Identite.query.filter(Identite.nom.ilike(f"%{term}%")).all()
list = []
content = {}
for etudiant in etudiants:
value = f"{sco_etud.format_nom(etudiant.nom)} {sco_etud.format_prenom(etudiant.prenom)}"
if etudiant.inscription_courante() is not None:
content = {
"id": f"{etudiant.id}",
"value": value,
"info": f"{etudiant.inscription_courante().formsemestre.titre}",
}
else:
content = {"id": f"{etudiant.id}", "value": value}
list.append(content)
content = {}
return jsonify(results=list)
@bp.route("/responsables")
@permission_required(Permission.RelationsEntreprisesChange)
def json_responsables():
"""
Permet de récuperer un JSON avec tous les étudiants
"""
if request.args.get("term") == None:
abort(400)
term = request.args.get("term").strip()
responsables = User.query.filter(
User.nom.ilike(f"%{term}%"), User.nom.is_not(None), User.prenom.is_not(None)
).all()
list = []
content = {}
for responsable in responsables:
value = f"{responsable.get_nomplogin()}"
content = {"id": f"{responsable.id}", "value": value, "info": ""}
list.append(content)
content = {}
return jsonify(results=list)
@bp.route("/export_entreprises")
@permission_required(Permission.RelationsEntreprisesExport)
def export_entreprises():
"""
Permet d'exporter la liste des entreprises sous format excel (.xlsx)
"""
entreprises = Entreprise.query.filter_by(visible=True).all()
if entreprises:
keys = ["siret", "nom", "adresse", "ville", "codepostal", "pays"]
titles = keys[:]
L = [
[entreprise.to_dict().get(k, "") for k in keys]
for entreprise in entreprises
]
title = "entreprises"
xlsx = sco_excel.excel_simple_table(titles=titles, lines=L, sheet_name=title)
filename = title
return scu.send_file(xlsx, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE)
else:
abort(404)
@bp.route("/get_import_entreprises_file_sample")
@permission_required(Permission.RelationsEntreprisesExport)
def get_import_entreprises_file_sample():
keys = [
"siret",
"nom_entreprise",
"adresse",
"ville",
"codepostal",
"pays",
"nom_contact",
"prenom_contact",
"telephone",
"mail",
"poste",
"service",
]
titles = keys[:]
title = "ImportEntreprises"
xlsx = sco_excel.excel_simple_table(titles=titles, sheet_name="Entreprises")
filename = title
return scu.send_file(xlsx, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE)
@bp.route("/import_entreprises", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesExport)
def import_entreprises():
form = ImportEntreprisesForm()
if form.validate_on_submit():
path = os.path.join(Config.SCODOC_VAR_DIR, "tmp")
file = form.fichier.data
filename = secure_filename(file.filename)
file.save(os.path.join(path, filename))
# print(sco_excel.excel_file_to_list(filename))
return render_template(
"entreprises/import_entreprises.html",
title=("Importation entreprises"),
form=form,
)
@bp.route("/export_contacts")
@permission_required(Permission.RelationsEntreprisesExport)
def export_contacts():
"""
Permet d'exporter la liste des contacts sous format excel (.xlsx)
"""
contacts = (
db.session.query(EntrepriseContact)
.join(Entreprise, EntrepriseContact.entreprise_id == Entreprise.id)
.filter_by(visible=True)
.all()
)
if contacts:
keys = ["nom", "prenom", "telephone", "mail", "poste", "service"]
titles = keys[:]
L = [[contact.to_dict().get(k, "") for k in keys] for contact in contacts]
title = "contacts"
xlsx = sco_excel.excel_simple_table(titles=titles, lines=L, sheet_name=title)
filename = title
return scu.send_file(xlsx, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE)
else:
abort(404)
@bp.route("/export_contacts_bis")
@permission_required(Permission.RelationsEntreprisesExport)
def export_contacts_bis():
"""
Permet d'exporter la liste des contacts avec leur entreprise sous format excel (.xlsx)
"""
contacts = (
db.session.query(EntrepriseContact)
.join(Entreprise, EntrepriseContact.entreprise_id == Entreprise.id)
.filter_by(visible=True)
.all()
)
if contacts:
keys = [
"nom",
"prenom",
"telephone",
"mail",
"poste",
"service",
"nom_entreprise",
"siret",
"adresse_entreprise",
"ville",
"codepostal",
"pays",
]
titles = keys[:]
L = [
[contact.to_dict_export().get(k, "") for k in keys] for contact in contacts
]
title = "contacts"
xlsx = sco_excel.excel_simple_table(titles=titles, lines=L, sheet_name=title)
filename = title
return scu.send_file(xlsx, filename, scu.XLSX_SUFFIX, scu.XLSX_MIMETYPE)
else:
abort(404)
@bp.route(
"/get_offre_file/<int:entreprise_id>/<int:offre_id>/<string:filedir>/<string:filename>"
)
@permission_required(Permission.RelationsEntreprisesView)
def get_offre_file(entreprise_id, offre_id, filedir, filename):
"""
Permet de télécharger un fichier d'une offre
"""
if os.path.isfile(
os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{entreprise_id}",
f"{offre_id}",
f"{filedir}",
f"{filename}",
)
):
return send_file(
os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{entreprise_id}",
f"{offre_id}",
f"{filedir}",
f"{filename}",
),
as_attachment=True,
)
else:
abort(404)
@bp.route("/add_offre_file/<int:offre_id>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def add_offre_file(offre_id):
"""
Permet d'ajouter un fichier à une offre
"""
offre = EntrepriseOffre.query.filter_by(id=offre_id).first_or_404()
form = AjoutFichierForm()
if form.validate_on_submit():
date = f"{datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}"
path = os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{offre.entreprise_id}",
f"{offre.id}",
f"{date}",
)
os.makedirs(path)
file = form.fichier.data
filename = secure_filename(file.filename)
file.save(os.path.join(path, filename))
flash("Le fichier a été ajouté a l'offre.")
return redirect(url_for("entreprises.fiche_entreprise", id=offre.entreprise_id))
return render_template(
"entreprises/form.html", title=("Ajout fichier à une offre"), form=form
)
@bp.route("/delete_offre_file/<int:offre_id>/<string:filedir>", methods=["GET", "POST"])
@permission_required(Permission.RelationsEntreprisesChange)
def delete_offre_file(offre_id, filedir):
"""
Permet de supprimer un fichier d'une offre
"""
offre = EntrepriseOffre.query.filter_by(id=offre_id).first_or_404()
form = SuppressionConfirmationForm()
if form.validate_on_submit():
path = os.path.join(
Config.SCODOC_VAR_DIR,
"entreprises",
f"{offre.entreprise_id}",
f"{offre_id}",
f"{filedir}",
)
if os.path.isdir(path):
shutil.rmtree(path)
flash("Le fichier relié à l'offre a été supprimé.")
return redirect(
url_for("entreprises.fiche_entreprise", id=offre.entreprise_id)
)
return render_template(
"entreprises/delete_confirmation.html",
title=("Suppression fichier d'une offre"),
form=form,
)
Reference in New Issue View Git Blame Copy Permalink