def _create_sa_wrapper(self):
"""."""
try:
wrapper = getSAWrapper(self.util_id)
except ValueError:
try:
if self.util_id is None:
self._new_utilid()
wrapper = createSAWrapper(
self.dsn,
forZope=True,
transactional=True,
extension_options={'initial_state': 'invalidated'},
engine_options=self.engine_options_dict,
name=self.util_id)
register_z3c(self.id, wrapper)
except ValueError:
try:
wrapper = getSAWrapper(self.util_id)
except LookupError:
wrapper = lookup_entry(self.id)
except Exception:
wrapper = None
return wrapper
def getInfosTouristiques(self, infoType, infoTypePk, location=None):
wrapper = getSAWrapper('gites_wallons')
InfoTouristique = wrapper.getMapper('info_touristique')
TypeInfoTouristique = wrapper.getMapper('type_info_touristique')
query = select([InfoTouristique.infotour_nom,
InfoTouristique.infotour_url,
InfoTouristique.infotour_gps_long,
InfoTouristique.infotour_gps_lat,
TypeInfoTouristique.typinfotour_nom_fr,
InfoTouristique.infotour_localite],
InfoTouristique.infotour_type_infotour_fk == infoTypePk)
if location:
query.append_whereclause(InfoTouristique.infotour_location.distance_sphere(location) < DISTANCE_METERS)
query.append_whereclause(TypeInfoTouristique.typinfotour_pk == InfoTouristique.infotour_type_infotour_fk)
infos = query.execute().fetchall()
results = []
for info in infos:
title = '<a href="http://%s" title="%s" target="_blank">%s</a>' % (info.infotour_url,
info.infotour_nom,
info.infotour_nom)
results.append({'types': [infoType],
'name': title,
'vicinity': info.infotour_localite,
'latitude': info.infotour_gps_lat,
'longitude': info.infotour_gps_long})
return results
def getSearchIndex(self, tableName):
"""
Returns the available search index in the table
"""
wrapper = getSAWrapper('gites_wallons')
table = wrapper.getMapper(tableName)
return ITableSearch(table()).searchableFields
def updateClasse(self):
"""
Updates un événement acté lié à un dossier
"""
fields = self.context.REQUEST
classePk = getattr(fields, 'classePk')
classeNom = getattr(fields, 'classeNom')
classeTitulaire01Pk = fields.get('classeTitulaire01Pk', None)
classeTitulaire02Pk = fields.get('classeTitulaire02Pk', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(ClasseIsm)
query = query.filter(ClasseIsm.classeism_pk == classePk)
classe = query.one()
classe.classeism_nom = unicode(classeNom, 'utf-8')
classe.classeism_titulaire_01_fk = classeTitulaire01Pk
classe.classeism_titulaire_02_fk = classeTitulaire02Pk
session.flush()
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"La classe a bien été modifiée !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-marie/ajouter-une-classe-ism?classePk=%s" % (portalUrl, classePk)
self.request.response.redirect(url)
return ''
def insertClasse(self):
"""
insère un nouvel classe
"""
fields = self.context.REQUEST
classeNom = getattr(fields, 'classeNom')
classeTitulaire01Pk = fields.get('classeTitulaire01Pk', None)
classeTitulaire02Pk = fields.get('classeTitulaire02Pk', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
newEntry = ClasseIsm(classeism_nom=classeNom,
classeism_titulaire_01_fk=classeTitulaire01Pk,
classeism_titulaire_02_fk=classeTitulaire02Pk)
session.add(newEntry)
session.flush()
session.refresh(newEntry)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"La nouvelle classe a bien été ajoutée !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-marie/ajouter-une-classe-ism" % (portalUrl)
self.request.response.redirect(url)
return ''
def getHebergementByNameOrPk(self, reference):
"""
Get the url of the hebergement by Pk or part of the name
"""
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
hebTable = wrapper.getMapper('hebergement')
try:
int(reference)
except ValueError:
pass
else:
# we have a heb pk to search for
hebergement = session.query(hebTable).get(reference)
if hebergement and int(hebergement.heb_site_public) == 1 and hebergement.proprio.pro_etat:
# L'hébergement doit être actif, ainsi que son propriétaire
hebURL = getMultiAdapter((hebergement.__of__(self.context.hebergement), self.request), name="url")
self.request.response.redirect(str(hebURL))
return ''
else:
portal = getToolByName(self.context, 'portal_url').getPortalObject()
return getMultiAdapter((portal, self.request),
name="unknown_gites")()
zope.interface.alsoProvides(self.request, IMapRequest)
return self.search_results()
def deleteEvenementActeDocumentByDocumentPk(self):
"""
suppression d'un fichier attache a un evenement acte dans la db
"""
fields = self.context.REQUEST
fichierNom = getattr(fields, 'fichierNom', None)
evenementActePk = getattr(fields, 'evenementActePk', None)
documentPk = getattr(fields, 'documentPk', None)
elevePk = getattr(fields, 'elevePk', None)
dossierDisciplinaire = self.getDossierByEleve(elevePk)
dossierDisciplinairePk = dossierDisciplinaire.dosdis_pk
auteurPk = self.getAuteurPk()
#suppression dans la table evenement_acte_document
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(EvenementActeDocument)
query = query.filter(EvenementActeDocument.eventactdoc_pk == documentPk)
document = query.one()
session.delete(document)
session.flush()
self.insertLogOperation('deleteEvenementActeDocumentFromDb', auteurPk, dossierDisciplinairePk, evenementActePk)
self.deleteEvenementActeDocumentFromLfs(fichierNom, auteurPk, dossierDisciplinairePk, evenementActePk)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le pdf a bien été suprimé !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-marie/la-salle-des-profs/gestion-des-dossiers-disciplinaires/ajouter-un-evenement-au-dossier?elevePk=%s" % (portalUrl, elevePk)
self.request.response.redirect(url)
return ''
def addEvenementActeDocument(self, evenementActePk, dossierDisciplinairePk):
"""
ajout d'un fichier dans le localfs 'localfs_ism_event_act'
comme document lié à une eventment acte
"""
ismTools = getMultiAdapter((self.context, self.request), name="manageISM")
dateCreation = ismTools.getTimeStamp()
auteurPk = self.getAuteurPk()
fields = self.context.REQUEST
evenementActeDocument = getattr(fields, 'fichierAttache')
dossierDisciplinairePk = getattr(fields, 'dossierDisciplinairePk')
lfsEventActe = getattr(self.context, 'localfs_ism_event_act')
lfs = getattr(lfsEventActe, 'localfs_ism_event_act')
filename, ext = os.path.splitext(evenementActeDocument.filename)
normalizedFilename = normalizeString(filename, encoding='utf-8')
nomFichier = '%s_dd%s_ev%s%s' % (normalizedFilename, dossierDisciplinairePk, evenementActePk, ext)
lfs.manage_upload(evenementActeDocument, id=nomFichier)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
newEntry = EvenementActeDocument(eventactdoc_date_creation=dateCreation,
eventactdoc_auteur_creation=auteurPk,
eventactdoc_nom_fichier=nomFichier,
eventactdoc_auteur_creation_fk=auteurPk,
eventactdoc_eventact_fk=evenementActePk,
eventactdoc_dossier_disciplinaire_fk=dossierDisciplinairePk)
session.add(newEntry)
session.flush()
self.insertLogOperation('addEvenementActeDocument', auteurPk, dossierDisciplinairePk, evenementActePk)
def deleteEvenementActe(self):
"""
Supprimer un événement acté lié à un dossier
"""
fields = self.request.form
elevePk = fields.get('elevePk')
evenementActePk = fields.get('evenementActePk', None)
dossierDisciplinairePk = fields.get('dossierDisciplinairePk', None)
auteurPk = self.getAuteurPk()
self.deleteLogModificationEvenementActe()
self.deleteAllEvenementActeDocumentByEvenementPk()
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(EvenementActe)
query = query.filter(EvenementActe.eventact_pk == evenementActePk)
evenementActe = query.one()
session.delete(evenementActe)
session.flush()
self.insertLogOperation('deleteEvenementActe', auteurPk, dossierDisciplinairePk, evenementActePk)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"L'événement a bien été supprimé !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-marie/la-salle-des-profs/gestion-des-dossiers-disciplinaires/ajouter-un-evenement-au-dossier?elevePk=%s" % (portalUrl, elevePk)
self.request.response.redirect(url)
return ''
def deleteDossierDisciplinaire(self):
"""
Supprimer un dossier disciplinaire et ses event actés
"""
fields = self.request.form
dossierDisciplinairePk = fields.get('dossierDisciplinairePk')
elevePk = fields.get('elevePk')
#evenementActePk = fields.get('evenementActePk', None)
auteurPk = self.getAuteurPk()
self.deleteEvenementActeByDossierDisciplinaire(dossierDisciplinairePk)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(DossierDisciplinaire)
query = query.filter(DossierDisciplinaire.dosdis_pk == dossierDisciplinairePk)
dossierDisciplinaire = query.one()
session.delete(dossierDisciplinaire)
session.flush()
self.deleteEleveDosDis(elevePk)
self.insertLogOperation('deleteDossierDisciplinaire', auteurPk, dossierDisciplinairePk)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le dossier disciplinaire et les événements qui lui sont liés ont bien été supprimés !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-marie/la-salle-des-profs/gestion-des-dossiers-disciplinaires/ajouter-un-dossier-disciplinaire" % (portalUrl)
self.request.response.redirect(url)
return ''
def createAndRegisterSAMapper(db_connector, table_name, db_schema,
table_name_absolute, mapper_class,
column_overrides=[], primary_keys=[]):
"""Open up our connection to a table in a database and do it early.
Specify your primary keys in a list in the primary_keys argument (column
IDs only.
You can override column definitions in the SQLAlchemy autoload
by specifying Column() objects in a list as the column_overrides argument.
These get passed into the table creator as the "override" technique.
See http://www.sqlalchemy.org/docs/core/schema.html#overriding-reflected-columns for more info.
"""
if db_connector=='':
return
sa_wrapper = getSAWrapper(db_connector)
table = Table(table_name,
sa_wrapper.metadata,
schema=db_schema,
*column_overrides,
autoload=True)
resolved_pks = [table.c.get(key) for key in primary_keys]
mapper_ = mapper(mapper_class,
table,
primary_key=resolved_pks,
properties={})
sa_wrapper.registerMapper(mapper_, name=table_name_absolute)
def getSearchingEleveDosDis(self, elevePk=None):
"""
table pg eleve
recuperation d'un auteur selon la pk
la pk peut arriver via le form en hidden ou via un lien construit,
(cas du listing de resultat de moteur de recherche)
je teste si la pk arrive par param, si pas je prends celle du form
"""
fields = self.request.form
eleveNom = fields.get('eleveNom', None)
if not elevePk:
elevePk = fields.get('eleve_pk')
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(EleveDossierDisciplinaire)
if eleveNom:
eleveNom = eleveNom.split(',')
eleveNom = eleveNom[0]
eleveNom = eleveNom.decode('utf-8')
query = query.filter(EleveDossierDisciplinaire.eleve_nom == eleveNom)
if elevePk:
query = query.filter(EleveDossierDisciplinaire.eleve_pk == elevePk)
allEleves = query.all()
return allEleves
def updateDemandeIntervention(self):
"""
table pg demande d'intervention
mise a jour d'une demande d'intervention
"""
commonTools = getMultiAdapter((self.context, self.request), name="manageCommon")
employeModification = commonTools.getUserAuthenticated()
fields = self.request.form
interventionPk = fields.get('interventionPk', None)
etatInterventionByIpplf = fields.get('etatInterventionByIpplf', None)
commentaireByIpplf = fields.get('commentaireByIpplf', None)
wrapper = getSAWrapper('ipplf')
session = wrapper.session
updateIntervention = wrapper.getMapper('demande_intervention')
query = session.query(updateIntervention)
query = query.filter(updateIntervention.di_pk == interventionPk)
demandeIntervention = query.one()
demandeIntervention.di_etat_ipplf = unicode(etatInterventionByIpplf, 'utf-8')
demandeIntervention.di_commentaire_ipplf = unicode(commentaireByIpplf, 'utf-8')
demandeIntervention.di_employe_modification = unicode(employeModification, 'utf-8')
session.flush()
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"L'intervention a bien été modifiée !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/detail-demande-d-intervention?diPk=%s" % (portalUrl, interventionPk)
self.request.response.redirect(url)
return ''
def insertProprioMaj(self):
"""
insère les infos mise à jour par proprio dans table provisoire
"""
fields = self.request
proPk = fields.get('pro_maj_propk')
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
insertProprioMaj = wrapper.getMapper('proprio_maj')
newEntry = insertProprioMaj(pro_maj_propk=proPk,\
pro_maj_civ_fk=fields.get('pro_maj_civ_fk'),\
pro_maj_nom1=fields.get('pro_maj_nom1'),\
pro_maj_prenom1=fields.get('pro_maj_prenom1'),\
pro_maj_nom2=fields.get('pro_maj_nom2'),\
pro_maj_prenom2=fields.get('pro_maj_prenom2'),\
pro_maj_societe=fields.get('pro_maj_societe'),\
pro_maj_adresse=fields.get('pro_maj_adresse'),\
pro_maj_com_fk=fields.get('pro_maj_com_fk'),\
pro_maj_email=fields.get('pro_maj_email'),\
pro_maj_tel_priv=fields.get('pro_maj_tel_priv'),\
pro_maj_fax_priv=fields.get('pro_maj_fax_priv'),\
pro_maj_gsm1=fields.get('pro_maj_gsm1'),\
pro_maj_tva=fields.get('pro_maj_tva'),\
pro_maj_langue=fields.get('pro_maj_langue'), \
pro_maj_date_naiss=fields.get('pro_maj_date_naiss') or None,\
)
session.add(newEntry)
session.flush()
def insertDossier(self, elevePk, eleveNom, eleveClasse):
"""
insère un nouveau dossier disciplinaire
"""
ismTools = getMultiAdapter((self.context, self.request), name="manageISM")
dossierDisciplianireID = self.getDossierId(elevePk, eleveNom, eleveClasse)
dossierDisciplianireAnneeScolaire = ismTools.getAnneeCourante()
dossierDisciplianireElevePk = elevePk
auteurPk = self.getAuteurPk()
wrapper = getSAWrapper('cesstex')
session = wrapper.session
newEntry = DossierDisciplinaire(dosdis_id=dossierDisciplianireID,
dosdis_annee_scolaire=dossierDisciplianireAnneeScolaire,
dosdis_actif=True,
dosdis_eleve_fk=dossierDisciplianireElevePk,
dosdis_auteur_fk=auteurPk)
session.add(newEntry)
session.flush()
session.refresh(newEntry)
dossierDisciplinairePk = newEntry.dosdis_pk
self.insertLogOperation('insertDossier', auteurPk, dossierDisciplinairePk)
self.sendMailForNewDossier(elevePk)
return ''
def getSearchingAffiche(self, affichePk=None, searchingLetter=None):
"""
table pg affiche
recuperation d'une affiche selon la pk
la pk peut arriver via le form en hidden ou via un lien construit,
(cas du listing de resultat de moteur de recherche)
je teste si la pk arrive par param, si pas je prends celle du form
"""
fields = self.request.form
afficheTitre = fields.get('afficheTitre')
if not affichePk:
affichePk = fields.get('affiche_pk')
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
AfficheTable = wrapper.getMapper('affiche')
query = session.query(AfficheTable)
if afficheTitre:
query = query.filter(AfficheTable.affiche_titre == afficheTitre)
if affichePk:
query = query.filter(AfficheTable.affiche_pk == affichePk)
if searchingLetter:
query = query.filter(AfficheTable.affiche_titre.ilike("%%%s" % searchingLetter))
allAffiches = query.all()
return allAffiches
def query(self, query_string, max_rows=None, query_data=None):
""" *The* query() method as used by the internal ZSQL
machinery.
"""
wrapper = getSAWrapper(self.sqlalchemy_wrapper_name)
c = wrapper.connection
rows = []
desc = None
nselects = 0
ts_start = time.time()
for qs in [x for x in query_string.split('\0') if x]:
LOG.debug(qs)
if query_data:
proxy = c.execute(qs, query_data)
else:
proxy = c.execute(qs)
description = proxy.cursor.description
if description is not None:
nselects += 1
if nselects > 1:
raise ValueError(
"Can't execute multiple SELECTs within a single query")
if max_rows:
rows = proxy.fetchmany(max_rows)
else:
rows = proxy.fetchall()
desc = description
types_map = self._typesMap(proxy)
LOG.debug('Execution time: %3.3f seconds' % (time.time() - ts_start))
if desc is None:
return [], None
items = []
for name, type_code, width, internal_size, precision, scale, null_ok in desc:
items.append({
'name':
name,
'type':
types_mapping.get(types_map.get(type_code, None), 's'),
'null':
null_ok,
'width':
width,
})
return items, rows
def getCapaciteTotalGroupementByPk(self, hebPk):
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
query = session.query(Hebergement.heb_nom.label('heb_nom'),
Hebergement.heb_cgt_nbre_chmbre.label('heb_cgt_nbre_chmbre'),
Hebergement.heb_cgt_cap_min.label('heb_cgt_cap_min'),
Hebergement.heb_cgt_cap_max.label('heb_cgt_cap_max'),
TypeHebergement.type_heb_id.label('heb_type'),
TypeHebergement.type_heb_type.label('heb_type_type'),
TypeHebergement.type_heb_code.label('heb_type_code'),
Hebergement.heb_code_gdw.label('heb_code_gdw'),
Hebergement.heb_pk.label('heb_pk'),
LinkHebergementEpis.heb_nombre_epis.label('heb_nombre_epis'),
Hebergement.heb_localite.label('heb_localite'),
Hebergement.heb_gps_long.label('heb_gps_long'),
Hebergement.heb_gps_lat.label('heb_gps_lat'),
Hebergement.heb_groupement_pk.label('heb_groupement_pk'),
HebergementApp.heb_app_groupement_line_length.label('heb_app_groupement_line_length'),
HebergementApp.heb_app_groupement_angle_start.label('heb_app_groupement_angle_start')
)
query = query.join('proprio').outerjoin('epis').join('type').join('app')
query = query.options(FromCache('gdw'))
query = query.filter(Hebergement.heb_groupement_pk == hebPk)
query = query.filter(sa.and_(Hebergement.heb_site_public == '1',
Proprio.pro_etat == True))
groupement = query.all()
nbreChambre = 0
nbrePersonneMin = 0
nbrePersonneMax = 0
for heb in groupement:
nbreChambre = nbreChambre + heb.heb_cgt_nbre_chmbre
nbrePersonneMin = nbrePersonneMin + heb.heb_cgt_cap_min
nbrePersonneMax = nbrePersonneMax + heb.heb_cgt_cap_max
return (nbreChambre, nbrePersonneMin, nbrePersonneMax)
def insertPeriodique(self):
"""
ajout d'un item periodique
"""
fields = self.context.REQUEST
periodiqueTitre = getattr(fields, 'periodiqueTitre')
periodiqueDescription = getattr(fields, 'periodiqueDescription', None)
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
insertPeriodique = wrapper.getMapper('periodique')
newEntry = insertPeriodique(per_titre=periodiqueTitre,
per_description=periodiqueDescription)
session.add(newEntry)
session.flush()
session.refresh(newEntry)
periodiquePk = newEntry.per_pk
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Vos informations ont été enregistrées !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/gestion-de-la-base/les-periodiques/admin-decrire-un-periodique?periodiquePk=%s" % (portalUrl, periodiquePk)
self.request.response.redirect(url)
return ''
def insertAuteur(self):
"""
table pg auteur
ajout d'un item Auteur
"""
fields = self.request.form
auteurNom = fields.get('auteurNom', None)
auteurPrenom = fields.get('auteurPrenom', None)
auteurNom = unicode(auteurNom, 'utf-8')
auteurPrenom = unicode(auteurPrenom, 'utf-8')
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
insertAuteur = wrapper.getMapper('auteur')
newEntry = insertAuteur(auteur_nom=auteurNom,
auteur_prenom=auteurPrenom)
session.add(newEntry)
session.flush()
session.refresh(newEntry)
auteurPk = newEntry.auteur_pk
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le nouvel auteur %s %s a bien été enregistré !" % (auteurNom, auteurPrenom)
ploneUtils.addPortalMessage(message, 'info')
url = "%s/gestion-de-la-base/les-auteurs/admin-decrire-un-auteur?auteurPk=%s" % (portalUrl, auteurPk)
self.request.response.redirect(url)
return ''
def updateAuteur(self):
"""
table pg auteur
mise a jour d'un item auteur
"""
fields = self.request.form
auteurPk = fields.get('auteurPk', None)
auteurNom = fields.get('auteurNom', None)
auteurPrenom = fields.get('auteurPrenom', None)
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
updateAuteurTable = wrapper.getMapper('auteur')
query = session.query(updateAuteurTable)
query = query.filter(updateAuteurTable.auteur_pk == auteurPk)
auteurs = query.all()
for auteur in auteurs:
auteur.auteur_nom = unicode(auteurNom, 'utf-8')
auteur.auteur_prenom = unicode(auteurPrenom, 'utf-8')
session.flush()
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"L'auteur %s %s a bien été modifié !" % (auteurNom, auteurPrenom)
ploneUtils.addPortalMessage(message, 'info')
url = "%s/gestion-de-la-base/les-auteurs/admin-decrire-un-auteur?auteurPk=%s" % (portalUrl, auteurPk)
self.request.response.redirect(url)
return ''
def deleteProfesseur(self):
"""
Supprimer un professeur
"""
fields = self.context.REQUEST
profPk = getattr(fields, 'profPk', None)
profLogin = getattr(fields, 'profLogin', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(Professeur)
query = query.filter(Professeur.prof_pk == profPk)
professeur = query.one()
session.delete(professeur)
session.flush()
self.delLoginProfesseur(profLogin)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le professeur a bien été supprimé !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-therese/ajouter-un-professeur-ist?profPk=%s" % (
portalUrl, profPk)
self.request.response.redirect(url)
return ''
def getSearchingAuteur(self, auteurPk=None):
"""
table pg auteur
recuperation d'un auteur selon la pk
la pk peut arriver via le form en hidden ou via un lien construit,
(cas du listing de resultat de moteur de recherche)
je teste si la pk arrive par param, si pas je prends celle du form
"""
fields = self.request.form
auteurNom = fields.get('auteurNom', None)
if not auteurPk:
auteurPk = fields.get('auteur_pk')
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
AuteurTable = wrapper.getMapper('auteur')
query = session.query(AuteurTable)
if auteurNom:
auteurNom = auteurNom.split(',')
auteurNom = auteurNom[0]
auteurNom = auteurNom.decode('utf-8')
auteurNom = auteurNom.capitalize()
query = query.filter(AuteurTable.auteur_nom == auteurNom)
if auteurPk:
query = query.filter(AuteurTable.auteur_pk == auteurPk)
allAuteurs = query.all()
return allAuteurs
def deleteEleve(self):
"""
Supprimer un élève
"""
fields = self.context.REQUEST
elevePk = getattr(fields, 'elevePk', None)
eleveLogin = getattr(fields, 'eleveLogin', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(EleveIsm)
query = query.filter(EleveIsm.eleveism_pk == elevePk)
eleve = query.one()
session.delete(eleve)
session.flush()
self.delLoginEleve(eleveLogin)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"L'élève' a bien été supprimé !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-marie/ajouter-un-eleve-ism?elevefPk=%s" % (portalUrl, elevePk)
self.request.response.redirect(url)
return ''
def deletePeriodique(self):
"""
table pg periodique
suppression des periodiques
"""
fields = self.context.REQUEST
periodiquePk = getattr(fields, 'periodiquePk')
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
deletePeriodiqueTable = wrapper.getMapper('periodique')
query = session.query(deletePeriodiqueTable)
query = query.filter(deletePeriodiqueTable.per_pk == periodiquePk)
allPeriodiques = query.all()
for periodiquePk in allPeriodiques:
session.delete(periodiquePk)
session.flush()
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le périodique a été supprimé !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/gestion-de-la-base/les-periodiques/" % (portalUrl, )
self.request.response.redirect(url)
return ''
def updatePeriodique(self):
"""
mise a jour d'un item periodique
"""
fields = self.context.REQUEST
periodiquePk = getattr(fields, 'periodiquePk')
periodiqueTitre = getattr(fields, 'periodiqueTitre', None)
periodiqueDescription = getattr(fields, 'periodiqueDescription', None)
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
updatePeriodiqueTable = wrapper.getMapper('periodique')
query = session.query(updatePeriodiqueTable)
query = query.filter(updatePeriodiqueTable.per_pk == periodiquePk)
periodiques = query.all()
for periodique in periodiques:
periodique.per_titre = unicode(periodiqueTitre, 'utf-8')
periodique.per_description = unicode(periodiqueDescription, 'utf-8')
session.flush()
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Vos informations ont été modifiées !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/gestion-de-la-base/les-periodiques/admin-decrire-un-periodique?periodiquePk=%s" % (portalUrl, periodiquePk)
self.request.response.redirect(url)
return ''
def handleApply(self, action):
data, errors = self.extractData()
if errors:
self.status = EditForm.formErrorsMessage
return
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
config = data.get('calendarConfig')
all_hebs = getHebergementsForProprio(
self.context,
session,
only_active=False,
)
for heb in all_hebs:
oldConfig = heb.heb_calendrier_proprio
heb.heb_calendrier_proprio = config
# mise à jour dernière date de modification du calendrier
heb.heb_calendrier_proprio_date_maj = date.today()
session.add(heb)
if oldConfig != config:
if config == u'non actif':
hebBlockHist = HebergementBlockingHistory()
hebBlockHist.heb_blockhistory_blocked_dte = date.today()
hebBlockHist.heb_blockhistory_heb_pk = heb.heb_pk
session.add(hebBlockHist)
else:
blockHist = self.getBlockedInfo(session, heb.heb_pk)
if blockHist is not None:
blockHist.heb_blockhistory_activated_dte = date.today()
blockedDate = blockHist.heb_blockhistory_activated_dte - blockHist.heb_blockhistory_blocked_dte
blockHist.heb_blockhistory_days = blockedDate.days
session.add(blockHist)
session.flush()
session.expunge_all()
self.status = ""
def getAuteurPkByAuteurNom(self, livrePk, auteurNom=None):
"""
table pg auteur
recuperation de la pk d'un auteur selon leur nom
à partir de la table livre
"""
if not auteurNom:
return''
else:
nom = auteurNom.split(', ')
auteurNom = nom[0]
print auteurNom
if len(nom) > 1:
auteurPrenom = nom[1]
else:
auteurPrenom = None
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
AuteurTable = wrapper.getMapper('auteur')
query = session.query(AuteurTable)
if auteurNom:
query = query.filter(AuteurTable.auteur_nom == auteurNom)
if auteurPrenom:
query = query.filter(AuteurTable.auteur_prenom == auteurPrenom)
auteur = query.one()
auteurPk = auteur.auteur_pk
return (livrePk, auteurPk)
def deleteProfesseur(self):
"""
Supprimer un professeur
"""
fields = self.context.REQUEST
profPk = getattr(fields, 'profPk', None)
profLogin = getattr(fields, 'profLogin', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(Professeur)
query = query.filter(Professeur.prof_pk == profPk)
professeur = query.one()
session.delete(professeur)
session.flush()
self.delLoginProfesseur(profLogin)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le professeur a bien été supprimé !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-therese/ajouter-un-professeur-ist?profPk=%s" % (portalUrl, profPk)
self.request.response.redirect(url)
return ''
def getLivresByAuteurNom(self, auteurNom=None):
"""
recuperation de tous les livres d'un auteur via son Nom
"""
auteurPk = []
if not auteurNom:
fields = self.request.form
auteurNom = fields.get('auteurNom', None)
else:
b = auteurNom.split('- ')
auteurPk.append(int(b[1]))
wrapper = getSAWrapper('cenforsoc')
session = wrapper.session
LinkLivreAuteurTable = wrapper.getMapper('link_livre_auteur')
query = session.query(LinkLivreAuteurTable)
for pk in auteurPk:
query = query.filter(LinkLivreAuteurTable.auteur_fk == pk)
allLivresPk = query.all()
allLivres = []
for livre in allLivresPk:
livrePk = livre.livres.liv_pk
livreTitre = livre.livres.liv_titre
allLivres.append((livrePk, livreTitre))
return allLivres
def insertHebergementMaj(self):
"""
ajoute les infos de mise à jour de l'hébergement par le proprio
table habergement_maj
met dans table hebergement le champ heb_maj_info_etat à 'En attente de confirmation'
"""
fields = self.context.REQUEST
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
insertHebergementMaj = wrapper.getMapper('hebergement_maj')
newEntry = insertHebergementMaj(
heb_maj_hebpk=fields.get('heb_maj_hebpk'),
heb_maj_nom=fields.get('heb_maj_nom'),
heb_maj_url=fields.get('heb_maj_url'),
heb_maj_adresse=fields.get('heb_maj_adresse'),
heb_maj_localite=fields.get('heb_maj_localite'),
heb_maj_descriptif_fr=fields.get('heb_maj_descriptif_fr'),
heb_maj_pointfort_fr=fields.get('heb_maj_pointfort_fr'),
heb_maj_forfait_montant=fields.get('heb_maj_forfait_montant'),
heb_maj_lit_1p=fields.get('heb_maj_lit_1p'),
heb_maj_lit_2p=fields.get('heb_maj_lit_2p'),
heb_maj_lit_sup=fields.get('heb_maj_lit_sup'),
heb_maj_lit_enf=fields.get('heb_maj_lit_enf'),
heb_maj_distribution_fr=fields.get('heb_maj_distribution_fr'),
heb_maj_charge_fk=fields.get('heb_maj_charge_fk'))
session.add(newEntry)
session.flush()
def updateProprioMaj(self):
"""
mise à jour des données maj du proprio
"""
fields = self.request
proMajProPk = fields.get('pro_maj_propk')
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
updateProprioMaj = wrapper.getMapper('proprio_maj')
query = session.query(updateProprioMaj)
query = query.filter(updateProprioMaj.pro_maj_propk == proMajProPk)
record = query.one()
record.pro_maj_civ_fk = fields.get('pro_maj_civ_fk')
record.pro_maj_nom1 = fields.get('pro_maj_nom1', '')
record.pro_maj_prenom1 = fields.get('pro_maj_prenom1', '')
record.pro_maj_nom2 = fields.get('pro_maj_nom2', '')
record.pro_maj_prenom2 = fields.get('pro_maj_prenom2', '')
record.pro_maj_societe = fields.get('pro_maj_societe', '')
record.pro_maj_adresse = fields.get('pro_maj_adresse', '')
record.pro_maj_com_fk = fields.get('pro_maj_com_fk')
record.pro_maj_email = fields.get('pro_maj_email')
record.pro_maj_tel_priv = fields.get('pro_maj_tel_priv')
record.pro_maj_fax_priv = fields.get('pro_maj_fax_priv')
record.pro_maj_gsm1 = fields.get('pro_maj_gsm1')
record.pro_maj_tva = fields.get('pro_maj_tva')
record.pro_maj_langue = fields.get('pro_maj_langue')
record.pro_maj_date_naiss = fields.get('pro_maj_date_naiss') or None
session.flush()
def deleteAfficheFromLocalFS(self, \
fileName, \
for_id=None):
"""
suppression du fichier dans le localfs
comme catalogue pdf de l'operateur
suppression dans la table link_organisme_formation
"""
#suppression dans le localfs
rof = getattr(self.context, 'rof-questionnaire')
lfs = getattr(rof, 'rof_pdf')
lfs.manage_delObjects(ids=fileName)
#suppression dans la table link_organisme_catalogue
wrapper = getSAWrapper('apef')
session = wrapper.session
deleteCatalogue = wrapper.getMapper('link_organisme_catalogue')
query = session.query(deleteCatalogue)
query = query.filter(deleteCatalogue.c.for_catalogue == fileName)
newEntries = query.all()
for newEntry in newEntries:
session.delete(newEntry)
session.flush()
if for_id:
cible = "%s/rof-questionnaire/operateur-gerer-catalogue-pdf" % self.context.portal_url()
else:
cible = "%s/rof-questionnaire/accueil" % self.context.portal_url()
self.context.REQUEST.RESPONSE.redirect(cible)
return ''
def _supply_z3c_sa_wrapper(self):
"""
Look up or create the underlying z3c.sqlalchemy `ZopeWrapper`.
"""
if not self.dsn:
return None
else:
try:
wrapper = getSAWrapper(self.util_id)
except ValueError:
try:
if self.util_id is None:
# the z3c.sqlalchemy registration doesn't register None values
# of util_id; we need something that will stick.
self._new_utilid()
wrapper = createSAWrapper(
self.dsn,
forZope=True,
transactional=self.transactional,
extension_options={'initial_state': 'invalidated'},
engine_options=self.engine_options,
name=self.util_id)
register_sa_wrapper(self.id, wrapper)
except ValueError as e:
# ...weird...could this be a timing issue during startup?
# We've seen log messages that look like this:
# "ValueError: SAWrapper '1435583419.58.0.991532919015' already registered.
# You can not register a wrapper twice under the same name."
# This makes little sense because we just tried a lookup under that
# name and did not find it. Wrapper did not exist in
# component registry, but did exist in the z3c.sqlalchemy
# registeredWrappers dict registry. Try recovering by using
# the module dict lookup.
logger.warning("Unexpected failure to create SAWrapper: " +
str(e))
try:
wrapper = getSAWrapper(self.util_id)
except LookupError as e:
logger.warning(
"SAWrapper lookup falling back to SQLAlchemyDA registry:"
+ str(e))
wrapper = lookup_sa_wrapper(self.id)
except Exception:
logger.exception(
"No z3c.sqlalchemy ZopeWrapper found or created!")
wrapper = None
return wrapper
def manage_stop(self, RESPONSE=None):
""" close engine """
wrapper = getSAWrapper(self.sqlalchemy_wrapper_name)
wrapper._engine.connection_provider._pool.dispose()
if RESPONSE:
msg = 'Database connection halted'
RESPONSE.redirect(self.absolute_url() +
'/manage_workspace?manage_tabs_message=%s' % msg)
def getAllStatutMembre(self):
"""
recuperation de tous les status des membres (prof, direction, educateur)
"""
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(StatutMembre)
query = query.order_by(StatutMembre.statmembre_statut)
allStatutMembre = query.all()
return allStatutMembre
def getProfesseurByPk(self, profPk):
"""
recuperation d'un professseur selon sa pk
"""
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(Professeur)
query = query.filter(Professeur.prof_pk == profPk)
professeur = query.one()
return professeur
def _wrapper(self):
if self.dsn:
try:
return getSAWrapper(self.util_id)
except ValueError:
return createSAWrapper(self.dsn,
forZope=True,
transactional=self.transactional,
name=self.util_id)
return None
def getEcoleDuProfesseur(self, ecolePK):
"""
recuperation de l'école d'un prof
table ecole ism=1 ist=2 po=3
"""
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(Ecole)
query = query.filter(Ecole.ecole_pk == ecolePK)
ecoleDuProfesseur = query.one()
return ecoleDuProfesseur
def getAllProfesseurs(self, ecole):
"""
recuperation de tous les professseurs selon ecole
table ecole ism=1 ist=2 po=3
"""
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(Professeur)
query = query.order_by(Professeur.prof_nom)
query = query.filter(Professeur.prof_ecole_fk == ecole)
allProfesseurs = query.all()
return allProfesseurs
def _wrapper(self):
if self.dsn:
try:
return getSAWrapper(self.util_id)
except ValueError:
return createSAWrapper(
self.dsn,
forZope=True,
transactional=self.transactional,
extension_options={'initial_state': 'invalidated'},
engine_options=self.engine_options,
name=self.util_id)
return None
def getDBServer(self):
if not self.dsn:
return None
self._v_thread_local.dbconns = getattr(self._v_thread_local, 'dbconns',
{})
dbserver = self._v_thread_local.dbconns.get(self.dsn, None)
if dbserver is None or not dbserver.adaptor.conn.is_valid:
try:
wrapper = getSAWrapper(self.dsn)
except ValueError:
wrapper = createSAWrapper(dsn=self.dsn, name=self.dsn)
#TODO: manage OperationalError on connection
dbserver = DBServer(wrapper.connection,
__import__(self.getDriver()))
self._v_thread_local.dbconns[self.dsn] = dbserver
return dbserver
def _wrapper(self):
if self.dsn:
try:
return getSAWrapper(self.util_id)
except ValueError:
return createSAWrapper(self.dsn,
forZope=True,
transactional=self.transactional,
engine_options={
'convert_unicode':
self.convert_unicode,
'encoding': self.encoding
},
name=self.util_id)
return None
def updateProfesseur(self):
"""
Update les informations d'un professeur
"""
fields = self.context.REQUEST
profPk = getattr(fields, 'profPk')
profNom = getattr(fields, 'profNom')
profPrenom = getattr(fields, 'profPrenom', None)
profEmail = getattr(fields, 'profEmail', None)
profEmailCesstex = getattr(fields, 'profEmailCesstex', None)
profLogin = getattr(fields, 'profLogin', None)
profPass = getattr(fields, 'profPass', None)
profStatutFk = getattr(fields, 'profStatutFk', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
query = session.query(Professeur)
query = query.filter(Professeur.prof_pk == profPk)
professeur = query.one()
professeur.prof_nom = unicode(profNom, 'utf-8')
professeur.prof_prenom = unicode(profPrenom, 'utf-8')
professeur.prof_email = unicode(profEmail, 'utf-8')
professeur.prof_email_id = unicode(profEmailCesstex, 'utf-8')
professeur.prof_login = unicode(profLogin, 'utf-8')
professeur.prof_pass = unicode(profPass, 'utf-8')
professeur.prof_statut_fk = int(profStatutFk)
session.flush()
userProf = ('%s %s') % (profPrenom, profNom)
userRole = 'ProfIST'
self.addLoginProfesseur(profLogin, profPass, userRole)
self.addInfoProfesseur(profLogin, profEmail, userProf)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le professeur a bien été modifié !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-therese/ajouter-un-professeur-ist?profPk=%s" % (
portalUrl, profPk)
self.request.response.redirect(url)
return ''
def insertProfesseur(self):
"""
insère un nouveau professeur
"""
fields = self.context.REQUEST
profNom = getattr(fields, 'profNom')
profPrenom = getattr(fields, 'profPrenom', None)
profEmail = getattr(fields, 'profEmail', None)
profEmailCesstex = getattr(fields, 'profEmailCesstex', None)
profLogin = getattr(fields, 'profLogin', None)
profPass = getattr(fields, 'profPass', None)
profStatutFk = getattr(fields, 'profStatutFk', None)
profEcoleFk = getattr(fields, 'profEcoleFk', None)
wrapper = getSAWrapper('cesstex')
session = wrapper.session
newEntry = Professeur(prof_nom=profNom,
prof_prenom=profPrenom,
prof_email=profEmail,
prof_email_id=profEmailCesstex,
prof_login=profLogin,
prof_pass=profPass,
prof_statut_fk=profStatutFk,
prof_ecole_fk=profEcoleFk)
session.add(newEntry)
session.flush()
session.refresh(newEntry)
userProf = ('%s %s') % (profPrenom, profNom)
userRole = 'ProfIST'
self.addLoginProfesseur(profLogin, profPass, userRole)
self.addInfoProfesseur(profLogin, profEmail, userProf)
portalUrl = getToolByName(self.context, 'portal_url')()
ploneUtils = getToolByName(self.context, 'plone_utils')
message = u"Le nouveau membre a bien été ajouté !"
ploneUtils.addPortalMessage(message, 'info')
url = "%s/institut-sainte-therese/ajouter-un-professeur-ist" % (
portalUrl)
self.request.response.redirect(url)
return ''
def testWrapperRegistration(self):
wrapper = createSAWrapper(self.dsn)
registerSAWrapper(wrapper, 'test.wrapper1')
wrapper2 = getSAWrapper('test.wrapper1')
self.assertEqual(wrapper, wrapper2)
def getInfo(self):
""" return a dict with additional information """
wrapper = getSAWrapper(self.sqlalchemy_wrapper_name)
d = wrapper.kw
d['DSN'] = wrapper.dsn
return d
def _wrapper(self):
return getSAWrapper(self.sqlalchemy_wrapper_name)
def getSession(self):
""" return a session instance """
wrapper = getSAWrapper(self.sqlalchemy_wrapper_name)
return wrapper.session
def getMapper(self, name):
""" return a mapper class """
wrapper = getSAWrapper(self.sqlalchemy_wrapper_name)
return wrapper.getMapper(name)
def testWrapperDirectRegistration(self):
wrapper = createSAWrapper(self.dsn, name='test.wrapper3')
wrapper2 = getSAWrapper('test.wrapper3')
self.assertEqual(wrapper, wrapper2)
def connected(self):
wrapper = getSAWrapper(self.sqlalchemy_wrapper_name)
return wrapper._engine.connection_provider._pool.checkedin() > 0
