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 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 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 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 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 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 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 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 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 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 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 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 getSearchIndex(self, tableName):
     """
     Returns the available search index in the table
     """
     wrapper = getSAWrapper('gites_wallons')
     table = wrapper.getMapper(tableName)
     return ITableSearch(table()).searchableFields

    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 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 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 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 ''