Ajax
Affiche le modal qui permet d'assigner un tag à un point du meeting
436745
public function ajaxJoinTagAction(Request $request)
    {

        if ($request->isXmlHttpRequest()) {

            $em = $this->getDoctrine()->getManager();

            /*
             * On envoie le formulaire en modal
             */
            $id = $request->request->get('idItem');
            $item = $em->getRepository('InterneSeanceBundle:Item')->find($id);
            $joinTagForm = null;

            $joinTagForm = $this->createForm(new JoinTagType(),$item,
                array('action' => $this->generateUrl('tag_join',array('item'=>$item))));

            return $this->render('InterneSeanceBundle:Tag:modal_join_tag.html.twig',array('form'=>$joinTagForm->createView()));

        }
        return new Response();
    }
100869
public function afficherListe($criteres = array(), $modeAffichage = '')
    {
        $html="";




        $html.="<script  >

            function insertOptionInSelect(idSelect, OptionValue, libelleValue)
            {
                nbElems = idSelect.options.length;
                idSelect.options[nbElems] = new Option(libelleValue, OptionValue);
                idSelect.options[nbElems].selected=true;
            }
            </script>
        ";

        $isResultatRecherche = false;
        $sqlMotCle = "";
        if (isset($this->variablesGet['motCle']) && $this->variablesGet['motCle']!='') {
            $sqlMotCle = " AND CONCAT(p.prenom, ' ', p.nom, ' ', p.description) LIKE \"%".mysql_real_escape_string($this->variablesGet['motCle'])."%\"";


            $isResultatRecherche = true;
        }






        $t = new Template('modules/archi/templates/');
        $t->set_filenames((array('personnesListe'=>'listePersonnes.tpl')));


        if (isset($this->variablesGet['modeAffichage']) && $this->variablesGet['modeAffichage']!="") {
            $modeAffichage = $this->variablesGet['modeAffichage'];
        }


        //newIdPersonneAdded
        switch ($modeAffichage) {
            case "nouveauDossier":
            case "modifEvenement":
                // si c'est un affichage apres un ajout ,  on renvoi le nouvel element au formulaire
                if (isset($criteres['newIdPersonneAdded']) && $criteres['newIdPersonneAdded']!='0') {
                    /*$t->assign_vars(array('codeJavascriptReturnNewElementAjoute'=>"
                    parent.document.getElementById(parent.document.getElementById('paramChampsAppelantPersonne').value).innerHTML+='<option value=".$criteres['newIdPersonneAdded']." selected>".$this->getPersonneLibelle($criteres['newIdPersonneAdded'])."</option>';
                    "));
                    */

                    $t->assign_vars(array('codeJavascriptReturnNewElementAjoute'=>"insertOptionInSelect(parent.document.getElementById(parent.document.getElementById('paramChampsAppelantPersonne').value), '".$criteres['newIdPersonneAdded']."', '".str_replace("'", "\'", $this->getPersonneLibelle($criteres['newIdPersonneAdded']))."')"));
                }
                break;

            default:
                break;
        }







        // analyse des criteres
        $sqlLettreCourante = '';

        // récupération du nombre de résultats par lettres
        $tabLettres = array();
        $sqlComptageResultat = 'SELECT LOWER(SUBSTRING(p.nom,  1, 1)) AS lettre FROM personne p
            WHERE 1 GROUP BY LOWER(SUBSTRING(p.nom,  1, 1))';
        $rep = $this->connexionBdd->requete($sqlComptageResultat);
        while ($res = mysql_fetch_object($rep)) {
            $tabLettres[] = $res->lettre;
        }

        // si aucune lettre n'est précisée,  on indique la première lettre ayant des résultats
        // si le tableau de lettres est défini
        // et que la première lettre n'existe pas ou que la première lettre n'existe pas dans le tableau
        if (count($tabLettres) > 0 and  (!isset($criteres['alphaPersonne']) or (!in_array($criteres['alphaPersonne'], $tabLettres)))) {
            $criteres['alphaPersonne'] = $tabLettres[0];
        }

        if (isset($criteres['alphaPersonne']) && !$isResultatRecherche) {
            $sqlLettreCourante = " AND LOWER(SUBSTRING(p.nom, 1, 1)) = '".$criteres['alphaPersonne']."' ";
        }

        $nbEnregistrementsParPage='5';
        if (isset($criteres['nbEnregistrements'])) {
            $nbEnregistrementsParPage=$criteres['nbEnregistrements'];
        }

        $debutEnregistrement = '0';
        if (isset($criteres['archiPagePersonne'])) {
            $debutEnregistrement = ($criteres['archiPagePersonne']-1)*$nbEnregistrementsParPage;
        }



        if (!$isResultatRecherche) {
            $t->assign_vars(array('listeAlphabetique' => $this->afficherListeAlphabetique('personneListe', '', $tabLettres))); // 'personneListe' correspond au cas d'affichage de index.php
        }

        $t->assign_vars(
            array(
                'urlAjout'=> $this->creerUrl('', 'afficherAjouterPersonne', array('noHeaderNoFooter'=>1, 'modeAffichage'=>$modeAffichage)),
                'urlRecherchePersonne' => $this->creerUrl('', 'personneListe'),
                'modeAffichage'=>$modeAffichage,
                'archiAffichage'=>'personneListe'
            )
        ); // pour urlRecherchePersonne,  noHeaderNoFooter et modeAffichage sont dans le formulaire en hidden vu que les variables du formulaire sont transmises en GET



        $reqNbPersonnes = "
                            SELECT 0
                            FROM personne p
                            WHERE 1=1
                            ".$sqlLettreCourante."
                            ".$sqlMotCle."
                                    ";

        $resNbPersonnes = $this->connexionBdd->requete($reqNbPersonnes);

        $nbEnregistrementTotaux = mysql_num_rows($resNbPersonnes);

        // nombre d'images affichées sur une page
        $nbEnregistrementsParPage = 5;
        $arrayPagination=$this->pagination(
            array(
                'nomParamPageCourante'=>'archiPageCourantePersonne',
                'nbEnregistrementsParPage'=>$nbEnregistrementsParPage,
                'nbEnregistrementsTotaux'=>$nbEnregistrementTotaux,
                'typeLiens'=>'noformulaire'
            )
        );


        $t->assign_vars(array('pagination'=>$arrayPagination['html']));

        // recuperation du nombre de personne de la lettre courante ,  pour les numeros de pages
        $reqPersonnes = "
            SELECT p.idPersonne as idPersonne,  m.nom as metier,  p.nom as nom,  p.prenom as prenom,  p.dateNaissance as dateNaissance,  p.dateDeces as dateDeces,  p.description as description
            FROM personne p
            LEFT JOIN metier m ON m.idMetier = p.idMetier
            WHERE 1=1
            ".$sqlLettreCourante."
            ".$sqlMotCle."
            ORDER BY p.nom
            LIMIT ".$arrayPagination['limitSqlDebut'].", ".$nbEnregistrementsParPage;



        $resPersonnes=$this->connexionBdd->requete($reqPersonnes);
        $nbEnregistrements = mysql_num_rows($resPersonnes);

        // recuperation du nombre de pages a afficher

        if ($nbEnregistrements > $nbEnregistrementsParPage) {
            if ($nbEnregistrements%$nbEnregistrementsParPage!=0) {
                // on prend la partie entiere de la division + 1

                $nbPages = intval($nbEnregistrements/$nbEnregistrementsParPage)+1;
            } else {
                $nbPages = $nbEnregistrements/$nbEnregistrementsParPage;
            }

            for ($i=1; $i<=$nbPages; $i++) {
                switch ($modeAffichage) {
                    case "nouveauDossier":
                    case "modifEvenement":
                        $t->assign_block_vars(
                            'pages',
                            array(
                            'page'=>$i,
                            'url'=>$this->creerUrl('', '', array_merge($this->variablesGet, array('archiPagePersonne'=>$i, 'archiAffichage'=>'afficheRecherchePersonnePopup'))),
                            'onclick'=>""
                            )
                        );
                        break;
                    default:
                        $t->assign_block_vars(
                            'pages',
                            array(
                            'page'=>$i,
                            'url'=>$this->creerUrl('', '', array_merge($this->variablesGet, array('archiPagePersonne'=>$i, 'archiAffichage'=>'personneListe'))),
                            'onclick'=>""
                            )
                        );
                        break;
                }
            }
        } else {
            $nbPages=1;
        }


        if ($nbEnregistrements>0) {
            mysql_data_seek($resPersonnes, $debutEnregistrement);
            $i=0;
            while ($i<$nbEnregistrementsParPage) {
                $fetchPersonne=mysql_fetch_assoc($resPersonnes);


                switch ($modeAffichage) {
                    case "nouveauDossier":
                    case "modifEvenement":
                        $t->assign_block_vars(
                            'personne',
                            array(
                            'nom'=>stripslashes($fetchPersonne['nom']),
                            'prenom'=>stripslashes($fetchPersonne['prenom']),
                            'metier'=>stripslashes($fetchPersonne['metier']),
                            'url'=>'#',
                            'onclick'=>"insertOptionInSelect(parent.document.getElementById('personnes'), '".str_replace("'", "\'", $fetchPersonne['idPersonne'])."', '".str_replace("'", "\'", $fetchPersonne['nom'])." ".str_replace("'", "\'", $fetchPersonne['prenom'])."')"
                            )
                        );
                        break;
                    default:
                        $t->assign_block_vars(
                            'personne',
                            array(
                            'url'=>$this->creerUrl('', 'personne', array('idPersonne'=>$fetchPersonne['idPersonne'])),
                            'nom'=>stripslashes($fetchPersonne['nom']),
                            'prenom'=>stripslashes($fetchPersonne['prenom']),
                            'metier'=>stripslashes($fetchPersonne['metier'])
                            )
                        );
                        break;
                }

                $i++;
            }
        } else {
            $t->assign_block_vars('noPersonne', array());
        }

        ob_start();
        $t->pparse('personnesListe');
        $html .= ob_get_contents();
        ob_end_clean();

        return $html;
    }
1234241
function(nombre, controlador, tags, opciones) {
    // Se establecen los objetos comunes a todos los dispositivos
    this.info = Object();
    this.info.nombre = nombre;
    this.conectado = false;
    this.noErrores = true;
    this.cola = new objCola();
    this.funciones = new funciones(this);
    this.log = new log(this.info.nombre);
    this.tags = tags;
    this.tiposMB = {
        BYTE: {bits: 8, funcion: 'Int8', endian: false},
        INT: {bits: 16, funcion: 'Int16', endian: true},
        UINT: {bits: 16, funcion: 'UInt16', endian: true},
        DINT: {bits: 32, funcion: 'Int32', endian: true},
        UDINT: {bits: 32, funcion: 'UInt32', endian: true}, 
        FLOAT: {bits: 32, funcion: 'Float', endian: true},
        DOUBLE: {bits: 64, funcion: 'Double', endian: true}
    }
    new require('./drivers/'+controlador+'/driver') (this); // Se integran las funciones del driver con el dispositivo actual
    utilidades.mezclarObjetos(opciones, this.info); // Se establecen los objetos particulares de cada dispositivo
    
    this.conectarRecursiva(); // Se conecta el dispositivo
    
    
    
    
    /*
     * Se establecen los eventos o Listeners que serán ejecutados en TODOS los dispositivos, sean del driver que sea
     */
    utilidades.eventos(this, {
        conexion: function() {
            this.conectado = true;
            this.comenzarCiclo();
            this.comprobarConexion();
            
            this.log.info("Conectado");
            this.emit("conectado");
        },
        desconexion: function() {
            if (this.conectado) {
                this.conectado = false;
               
                this.cola.vaciar();
                
                this.log.error("Desconectado");
                this.emit("desconectado");
                this.conectarRecursiva();
            }
        },
        datosRecibidos: function(datos) {
            var buffer = utilidades.extractorBuffer(datos, this.estructuraCabecera, this.tiposMB, this.bytesPorPosicion, this.endian, this.noErrores);   
            if (typeof this.cola.operaciones[buffer.operacion] === 'undefined') {
                this.cola.prepararCola();
                return false;
            }
            
            var numOperacion = buffer.operacion;
            var operacion = this.cola.operaciones[numOperacion];
            var numPaquete = operacion.paquete;
            var paquete = this.cola.paquetes[numPaquete];

            if ((paquete.operaciones.lastIndexOf(numOperacion) === -1) || (typeof this.funciones[paquete.funcion+"Callback"] === 'undefined')) {
                this.cola.prepararCola();
                return false;
            }
            
            var informacion = this.funciones[paquete.funcion+"Callback"](buffer, numOperacion, operacion, numPaquete, paquete);            
            if (paquete.operaciones.length == 1) {
                if (this.cola.quitarPaquete(numPaquete)) {
                    if (typeof paquete.callback == 'function') {
                        if (typeof informacion == 'object') {
                            var array = utilidades.obj2arr(informacion);
                        }

                        paquete.callback.apply(this, array);
                    }
                }
            } else {
                this.cola.quitarOperacion(numOperacion);
            }
            
            this.cola.prepararCola();
            return true;
        },
        error: function() {
            if (this.conectado) {
                this.log.error("Se ha producido un error. Reconectamos el dispositivo...");
                this.emit("desconexion");
            }
        }
    });

    // Alias para los eventos
    this.on("conectado", function() {
        this.emit("connected");
    });
    this.on("desconectado", function() {
        this.emit("disconnected");
    });
    
    
    events.call(this); // Función de llamada a los eventos personalizados
}
255761
public function enregistreCommentaireEvenement()
    {
        $auth = new archiAuthentification();
        $fieldsCommentaires=$this->getCommentairesFields();
        $formulaire = new formGenerator();

        if ($auth->estConnecte()) {
            unset($fieldsCommentaires['captcha']);
        }
        $error = $formulaire->getArrayFromPost($fieldsCommentaires);
        if (count($error)==0) {
            $idUtilisateur=0;
            if ($auth->estConnecte()) {
                $idUtilisateur = $auth->getIdUtilisateur();
                // suite au SPAM mise en place d'un champ CommentaireValide 0/1 (by fabien 13/01/2012)
                $CommentaireValide=1;
                $user = new archiUtilisateur();
                $userInfos = $user->getArrayInfosFromUtilisateur($idUtilisateur);
            } else {
                $CommentaireValide=0;
            }

            // enregistrement du nouveau commentaire
            //$req = "insert into commentaires (nom,prenom,email,commentaire,idEvenementGroupeAdresse,date,idUtilisateur) values (\"".addslashes(strip_tags($this->variablesPost['nom']))."\",\"".addslashes(strip_tags($this->variablesPost['prenom']))."\",\"".addslashes(strip_tags($this->variablesPost['email']))."\",\"".addslashes(strip_tags($this->variablesPost['commentaire']))."\",'".$this->variablesPost['idEvenementGroupeAdresse']."',now(),'".$idUtilisateur."')";
            $nom=$auth->estConnecte()?$userInfos["nom"]:$this->variablesPost['nom'];
            $prenom=$auth->estConnecte()?$userInfos["prenom"]:$this->variablesPost['prenom'];
            $email=$auth->estConnecte()?$user->getMailUtilisateur($idUtilisateur):$this->variablesPost['email'];
            $uniqid = uniqid(null, true);
            //$req = "insert into commentaires (nom,prenom,email,commentaire,idEvenementGroupeAdresse,date,idUtilisateur) values (\"".addslashes(strip_tags($this->variablesPost['nom']))."\",\"".addslashes(strip_tags($this->variablesPost['prenom']))."\",\"".addslashes(strip_tags($this->variablesPost['email']))."\",\"".addslashes(strip_tags($this->variablesPost['commentaire']))."\",'".$this->variablesPost['idEvenementGroupeAdresse']."',now(),'".$idUtilisateur."')";
            $req = "INSERT INTO commentairesEvenement (nom,prenom,email,commentaire, idEvenement, date, idUtilisateur, CommentaireValide)
					VALUES (\"".addslashes(strip_tags($this->variablesPost['nom']))."\",\"".addslashes(strip_tags($this->variablesPost['prenom']))."\",\"".addslashes(strip_tags($this->variablesPost['email']))."\",'".mysql_real_escape_string(strip_tags($this->variablesPost['commentaire']))."', '".mysql_real_escape_string($this->variablesPost['idEvenementGroupeAdresse'])."', now(), '".mysql_real_escape_string($idUtilisateur). "'," . mysql_real_escape_string($CommentaireValide).")";
            $res = $this->connexionBdd->requete($req);
            // retour a l'affichage de l'adresse
            $idAdresse = $this->variablesPost['idEvenementGroupeAdresse'];
            $idEvenement = $this->variablesPost['idEvenementGroupeAdresse'];
            $idEvenementGroupeAdresse = $this->getIdEvenementGroupeAdresseFromIdEvenement($idEvenement);
            $idAdresse=$this->getIdAdresseFromIdEvenementGroupeAdresse($idEvenementGroupeAdresse);


            $idCommentaire = mysql_insert_id();

            // ************************
            // envoi d'un mail a tous les participants pour le groupe d'adresse
            // ************************
            $mail = new mailObject();
            $utilisateur = new archiUtilisateur();
            $arrayUtilisateurs = $utilisateur->getParticipantsCommentairesEvenement($this->variablesPost['idEvenementGroupeAdresse']);
            //$arrayCreatorAdresse = $utilisateur->getCreatorsFromAdresseFrom($this->variablesPost['idEvenementGroupeAdresse'],'idEvenementGroupeAdresse');
            //$arrayUtilisateurs = array_merge($arrayUtilisateurs,$arrayCreatorAdresse);
            $arrayUtilisateurs = array_unique($arrayUtilisateurs);
            $intituleAdresse = $this->getIntituleAdresseFrom($idEvenement, 'idEvenement');
            if (empty($intituleAdresse)) {
                $intituleAdresse = 'Voir le commentaire';
            }
            $idPerson = archiPersonne::isPerson($idEvenementGroupeAdresse);
            //$idAdresse = $this->getIdEvenementFromIdHistoriqueEvenement($this->variablesPost['idEvenementGroupeAdresse']);

            foreach ($arrayUtilisateurs as $indice => $idUtilisateurAdresse) {
                if ($idUtilisateurAdresse != $auth->getIdUtilisateur()) {
                    $infosUtilisateur = $utilisateur->getArrayInfosFromUtilisateur($idUtilisateurAdresse);
                    if ($infosUtilisateur['alerteCommentaires']=='1' && $infosUtilisateur['compteActif']=='1' && $infosUtilisateur['idProfil']!='4') {
                        $message = "Un utilisateur a ajouté un commentaire sur un evenement que vous avez créé.";
                        if ($idPerson) {
                            $message .="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>'personne', 'id'=>$idPerson)).'#commentaireEvenement'.$idCommentaire."'>".$intituleAdresse."</a><br>";
                        } else {
                            $message.= "Pour vous rendre sur l'adresse : <a href='".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail','archiIdAdresse'=>$idAdresse,'archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse)).'#commentaireEvenement'.$idCommentaire."'>".$intituleAdresse."</a><br>";
                        }
                        $message.= $this->getMessageDesabonnerAlerteMail();
                        $mail->sendMail($mail->getSiteMail(), $infosUtilisateur['mail'], 'Ajout d\'un commentaire sur une adresse sur laquelle vous avez participé.', $message, true);
                    }
                }
            }
            // ************************


            // envoi d'un mail aux administrateur pour la moderation
            $message="Merci d'avoir laissé un commentaire sur Archi-Strasbourg.<br>";
            $message .= "Afin qu'il soit publié, merci de le valider en cliquant sur ";
            $message .="<a href='".$this->getUrlRacine()."script/validateEmail.php?uniqid=".urlencode($uniqid)."'>ce lien</a>.<br>";
            $message .="<br/>Cordialement,</br>";
            $mail = new mailObject();

            $envoyeur['envoyeur'] = $mail->getSiteMail();
            $envoyeur['replyTo'] = strip_tags($this->variablesPost['email']);
            $u = new archiUtilisateur();
            if (!$CommentaireValide) {
                $mail->sendMail($envoyeur['envoyeur'], $this->variablesPost['email'], 'Votre commentaire sur Archi-Strasbourg', $message, true);
            } else {
                $message="Un utilisateur a ajouté un commentaire sur archiV2 : <br>";
                $message .= "nom ou pseudo : ".strip_tags($this->variablesPost['nom'])."<br>";
                $message .= "prenom : ".strip_tags($this->variablesPost['prenom'])."<br>";
                $message .= "email : ".strip_tags($this->variablesPost['email'])."<br>";
                $message .= "commentaire : ".stripslashes(strip_tags($this->variablesPost['commentaire']))."<br>";
                $idPerson = archiPersonne::isPerson($idEvenementGroupeAdresse);
                if ($idPerson) {
                    $message .="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>'personne', 'id'=>$idPerson)).'#commentaireEvenement'.$idCommentaire."'>".$intituleAdresse."</a><br>";
                } else {
                    $message .="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail','archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse,'archiIdAdresse'=>$idAdresse)).'#commentaireEvenement'.$idCommentaire."'>".$intituleAdresse."</a><br>";
                }

                $mail->sendMailToAdministrators($envoyeur, 'Un utilisateur a ajouté un commentaire', $message, " AND alerteCommentaires='1' ", true, true);
                // envoi mail aussi au moderateur si ajout sur adresse de ville que celui ci modere
                $arrayVilles=array();
                $arrayVilles[] = $this->getIdVilleFrom($idEvenement, 'idEvenement');
                $arrayVilles = array_unique($arrayVilles);
                $arrayListeModerateurs = $u->getArrayIdModerateursActifsFromVille($arrayVilles[0], array("sqlWhere"=>" AND alerteCommentaires='1' "));
                if (count($arrayListeModerateurs)>0) {
                    foreach ($arrayListeModerateurs as $indice => $idModerateur) {
                        if ($auth->getIdUtilisateur()!=$idModerateur) {
                            $mailModerateur = $u->getMailUtilisateur($idModerateur);

                            $mail->sendMail($mail->getSiteMail(), $mailModerateur, 'Un utilisateur a ajouté un commentaire', $message, true);
                        }
                    }
                }
            }

            // remise a zero des variables en post sinon on va reafficher les infos
            $_POST['commentaire']="";
            $_POST['email']="";
            $_POST['nom']="";
            $_POST['prenom']="";


            $idGroupeEvenement = $this->getIdEvenementGroupeAdresseFromIdEvenement($this->variablesPost['idEvenementGroupeAdresse']);
            $idAdresse = $this->getIdAdresseFromIdEvenementGroupeAdresse($idGroupeEvenement);

            $adresse = new archiAdresse();

            $this->messages->addConfirmation("Commentaire enregistré !");

            switch ($this->variablesPost['type']) {
                case 'evenement':
                    header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail', 'archiIdAdresse'=>$idAdresse, 'archiIdEvenementGroupeAdresse'=>$idGroupeEvenement), false, false).'#commentaireEvenement'.$idCommentaire);
                    break;
                case 'personne':
                    $e = new archiEvenement();
                    $idEvenementGA = $e->getIdEvenementGroupeAdresseFromIdEvenement($this->variablesPost['idEvenementGroupeAdresse']);
                    header("Location: ".$this->creerUrl('', 'evenementListe', array('selection' => 'personne', 'id' => archiPersonne::isPerson($idEvenementGA))).'#commentaireEvenement'.$idCommentaire);
                    break;
                default:
                    header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail', 'archiIdAdresse'=>$idAdresse, 'archiIdEvenementGroupeAdresse'=>$idGroupeEvenement), false, false).'#commentaireEvenement'.$idCommentaire);
            }
        } else {
            header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail', 'archiIdAdresse'=>$idAdresse, 'archiIdEvenementGroupeAdresse'=>$idGroupeEvenement), false, false));

            $this->erreurs->ajouter('Il y a une erreur dans le formulaire.');
            echo $this->erreurs->afficher();
            echo $this->getFormComment($this->variablesPost['idEvenementGroupeAdresse'], $fieldsCommentaires, 'evenement');
            echo $this->getListCommentairesEvenements($this->variablesPost['idEvenementGroupeAdresse']);
        }
    }
759332
function(oEvent) {
			var sEntityType,
				sEntityId,
				aSplit,
				sId = oEvent.getParameter("arguments").id;

			if (sId) {
				aSplit = sId.split("#");
				if (aSplit.length === 2) {
					sId = aSplit[0];
					sEntityType = aSplit[1];

					aSplit = sEntityType.split(":");
					if (aSplit.length === 2) {
						sEntityType = aSplit[0];
						sEntityId = aSplit[1];
					}
				}

				sId = sId.replace(/.html$/, "");

				if (sEntityType === 'event') { // legacy keyword is singular
					sEntityType = "events";
				}
			}

			this.navTo("apiId", {id: sId, entityType: sEntityType, entityId: sEntityId});
		}
125918
function(event, context, callback, selector) {
        var options = this.options;

        // Replace tokens
        if (event === '{mode}') {
            event = options.mode;
        }

        if (selector === '{selector}') {
            selector = this.nodes ? this.nodes.selector : '';
        }

        // Find and bind the function
        if ($.type(callback) === 'string') {
            callback = this[callback].bind(this);
        }

        this.__events.push([event, context, callback, selector]);
    }
97134
function(message, callback) {

						if (!F2.isInit()) {
							F2.log('F2.init() must be called before F2.UI.Modals.alert()');
							return;
						}

						if (F2.Rpc.isRemote(_appConfig.instanceId)) {
							F2.Rpc.call(
								_appConfig.instanceId,
								F2.Constants.Sockets.UI_RPC,
								'Modals.alert',
								[].slice.call(arguments)
							);
						} else {
							// display the alert
							jQuery(_renderAlert(message))
								.on('show.bs.modal', function() {
									var modal = this;
									jQuery(modal).find('.btn-primary').on('click', function() {
										jQuery(modal).modal('hide').remove();
										(callback || jQuery.noop)();
									});
								})
								.modal({backdrop:true});
						}
					}
1008288
public function displayHelp()
    {
        printf("%s\n", $this->getUsage());
        printf("%s\n", $this->getDescription());


        // Les options non incluses dans un groupe
        if (count(self::$arr_opt)) {
            foreach (self::$arr_opt as $arg) {
                printf("%s\n", rtrim($arg));
            }
        }

        // Options faisant partie d’un groupe
        if (count(self::$arr_group)) {
            foreach (self::$arr_group as $group) {
                if (count($group->args)) {
                    print("\n\n");

                    if ($group->name) {
                        $name = $group->name;

                        if ($this->obj_color->label || $this->obj_color->bold) {
                            $name = new Ansi($name);

                            if ($this->obj_color->label) {
                                $name->fg($this->obj_color->label);
                            }

                            if ($this->obj_color->bold) {
                                $name->bold;
                            }
                        }

                        printf("%s\n", $name);
                    }
                    foreach ($group->args as $arg) {
                        printf("%s\n", rtrim($arg));
                    }
                }
            }
        }

        exit();
    }
619141
public function afficheFormulaire($tabTravail = array(), $modif = '', $idParent = 0, $typeParentId = '')
    {
        $html = '';
        $t = new Template('modules/archi/templates/');
        //$t->set_filenames((array('evl'=>'evenementFormulaire.tpl')));
        $t->set_filenames((array('evl'=>'nouveauDossier.tpl')));
        $isEvenementGroupeAdresse = false;

        $formulaire = new formGenerator();

        $groupeTypeEvenement=2; // par defaut on selectionne les evenement de type 'travaux'
        if (isset($this->variablesPost['typeGroupeEvenement']) && $this->variablesPost['typeGroupeEvenement']!='') {
            $groupeTypeEvenement = $this->variablesPost['typeGroupeEvenement'];
        }


        $t->assign_vars(array('typeBoutonValidation'=>"button")); // quand test javascript sur les champs de l'adresse , type = button

        // cas d'ajout d'un sous evenement ou d'un evenement appartenant a une adresse
        // on n'affiche pas les listes d'evenements et d'adresses
        if ($idParent<>0) {
        // est ce que l'on veut lier l'evenement a un evenement que l'on a précisé en parametre ou a une adresse ?
            switch ($typeParentId) {
                case 'evenement':
                    // CAS OU L'ON VA AJOUTER UN SOUS EVENEMENT A L'EVENEMENT GROUPE d'ADRESSE
                    $t->assign_block_vars('isNotAjoutNouvelleAdresse', array());

                    if ($idPerson=archiPersonne::isPerson($idParent)) {
                        $person= new archiPersonne();

                        $infos=$person->getInfosPersonne($idPerson);
                        $t->assign_vars(array('recapitulatifAdresse'=>"<h2 class='h1'><a href='".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson))."'>".$infos["prenom"]." ".$infos["nom"]."</a></h2>"));
                    } else {
                        $adresse = new archiAdresse();
                        $t->assign_vars(array('recapitulatifAdresse'=>$adresse->afficherRecapitulatifAdresses($idParent)));
                    }
                        $t->assign_block_vars('afficheAjoutEvenement', array());
                        //$t->assign_block_vars('isNotAffichageGroupeAdresse',array());
                        $t->assign_vars(array('evenementGroupeAdresse'=>$idParent));
                        $t->assign_vars(array('nomBoutonValidation'=>'ajoutSousEvenement'));
                        $t->assign_vars(array('typeBoutonValidation'=>"submit"));
                    break;
                case 'adresse':
                    $tabTravail['adresses']['value']=array($idParent);
                    $t->assign_block_vars('ajouterAdresses', array());
                    break;
            }
        } else {
            // l'evenement est il un groupe d'adresse , si oui , on n'affichera que le champ des adresses
            if ($modif != '') {
            // c'est une modification d'evenement

                // on affiche le recapitulatif de l'adresse en haut de page
                $t->assign_block_vars('isNotAjoutNouvelleAdresse', array());


                $idEvenementGroupeAdresse = $this->getParent($modif);


                $adresse = new archiAdresse();

                if ($idPerson=archiPersonne::isPerson($idEvenementGroupeAdresse)) {
                    $person= new archiPersonne();
                    $infos=$person->getInfosPersonne($idPerson);
                    $t->assign_vars(array('recapitulatifAdresse'=>"<h2 class='h1'><a href='".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson))."'>".$infos["prenom"]." ".$infos["nom"]."</a></h2>"));
                } else {
                    $t->assign_vars(array('recapitulatifAdresse'=>$adresse->afficherRecapitulatifAdresses($idEvenementGroupeAdresse)));
                }

                $t->assign_vars(array('recaptitulatifAncres'=>$this->afficherRecapitulatifAncres($idEvenementGroupeAdresse, $modif)));

                $t->assign_vars(array("liensModifEvenements"=>$this->afficherLiensModificationEvenement($modif)));


                $isEvenementGroupeAdresse = $this->isEvenementGroupeAdresse($modif);
                if ($isEvenementGroupeAdresse) {
                // l'evenement courant est de type groupe d'adresse
                    // on affiche rien a par l'adresse

                    // on renseigne le champs cache du formulaire pour recuperer rapidement l'identifiant lors de la validation de la modification
                    $t->assign_vars(array('evenementGroupeAdresse'=>$modif));

                    $t->assign_block_vars('ajouterAdresses', array());

                    //on recupere les adresses liées a cet evenement
                    $reqAdressesGroupeAdresses = "
							SELECT ha.idAdresse as idAdresse
							from historiqueAdresse ha2, historiqueAdresse ha
							right join _adresseEvenement ae on ae.idAdresse = ha.idAdresse
							where ae.idEvenement = '".$modif."'
									and ha2.idAdresse = ha.idAdresse
									group by ha.idAdresse,ha.idHistoriqueAdresse
									having ha.idHistoriqueAdresse = max(ha2.idHistoriqueAdresse)
									";
                    $resAdressesGroupeAdresses = $this->connexionBdd->requete($reqAdressesGroupeAdresses);
                    while ($fetchAdressesGroupeAdresses = mysql_fetch_assoc($resAdressesGroupeAdresses)) {
                        $tabTravail["adresses"]['value'][] = $fetchAdressesGroupeAdresses['idAdresse'];
                    }
                } else {
                    // MODIFICATION d'UN EVENEMENT (juste l'evenement, pas d'adresse , pas de groupe d'adresse)
                    // initialisation des champs du template que l'on va afficher
                    $t->assign_block_vars('afficheAjoutEvenement', array());
                    $t->assign_vars(array('nomBoutonValidation'=>'evenementSimple'));
                    $t->assign_vars(array('typeBoutonValidation'=>"submit"));
                }
            } else {
                // ce n'est pas une modification d'evenement
                $t->assign_block_vars('afficheAjoutEvenement', array());
            }
        }


        //***********************************************************************************************
        // TYPE STRUCTURE
        // dans le cas d'un ajout de sous evenement
        // par defaut on recupere le type de structure du premier evenement enregistré 'qui n'est pas un groupe d'adresses'
        //***********************************************************************************************
        $heriteIdTypeStructure='';
        if ($idParent<>'0' && $typeParentId=='evenement') {
            $sqlTypeStructureHerite = "
					SELECT he.idTypeStructure as idTypeStructure
					FROM evenements he2, evenements he
					WHERE he.idEvenement =(select min(ee.idEvenementAssocie) from _evenementEvenement ee where ee.idEvenement = '".$idParent."')
							AND he2.idEvenement = he.idEvenement
							GROUP BY he.idEvenement
							";

            $resTypeStructureHerite = $this->connexionBdd->requete($sqlTypeStructureHerite);

            if (mysql_num_rows($resTypeStructureHerite)==1) {
                $fetchTypeStructureHerite = mysql_fetch_assoc($resTypeStructureHerite);
                $heriteIdTypeStructure = $fetchTypeStructureHerite['idTypeStructure'];
            }
            //echo "heriteIdTypeStructure=".$heriteIdTypeStructure;
        }
        if (!isset($idEvenementGroupeAdresse)) {
            $idEvenementGroupeAdresse=$_GET["archiIdEvenement"];
        }

        if (!archiPersonne::isPerson($idEvenementGroupeAdresse)) {
            $t->assign_block_vars("afficheAjoutEvenement.isAddress", array());
            $sqlTypeStructure = 'SELECT idTypeStructure, nom FROM typeStructure order by nom';
            if ($result = $this->connexionBdd->requete($sqlTypeStructure)) {
                while ($fetchTypeStructure = mysql_fetch_object($result)) {
                    if ($fetchTypeStructure->idTypeStructure !=0) {
                        //$tabTypeStructure[$rep->idTypeStructure] = $rep->nom;
                        if ((isset($tabTravail['typeStructure']) && $tabTravail['typeStructure']['value'] == $fetchTypeStructure->idTypeStructure) || ( $heriteIdTypeStructure!='' && $fetchTypeStructure->idTypeStructure == $heriteIdTypeStructure )) {
                            $selected = 'selected="selected"';
                        } else {
                            $selected = '';
                        }
                        $t->assign_block_vars(
                            'afficheAjoutEvenement.isAddress.typesStructure',
                            array(
                                        'id'=> $fetchTypeStructure->idTypeStructure,
                                        'nom'=> $fetchTypeStructure->nom,
                                        'selected'=> $selected
                                )
                        );
                    }
                }
            }
        }

        // ***********************************************************************************
        // si la personne n'est pas admin elle verra une version simplifiée du formulaire
        $authentification = new archiAuthentification();
        if ($authentification->estConnecte() && $authentification->estAdmin()) {
            $t->assign_block_vars('afficheAjoutEvenement.isAdmin', array());
        } else {
            $t->assign_block_vars('afficheAjoutEvenement.isNotAdmin', array());
        }
        // ******
        // ***********************************************************************************
        // autre cas pour l'affichage du champ numeroArchive , il faut que l'utilisateur soit autorisé à l'afficher => table utilisateur
        $utilisateur = new archiUtilisateur();
        if ($utilisateur->canChangeNumeroArchiveField(array('idUtilisateur'=>$authentification->getIdUtilisateur()))) {
            $t->assign_block_vars('afficheAjoutEvenement.canChangeNumeroArchive', array());
        } else {
            $t->assign_block_vars('afficheAjoutEvenement.noChangeNumeroArchive', array());
        }

        if ($utilisateur->canChangeDateFinField(array('idUtilisateur'=>$authentification->getIdUtilisateur()))) {
            $t->assign_block_vars('afficheAjoutEvenement.canChangeDateFin', array());
        } else {
            $t->assign_block_vars('afficheAjoutEvenement.noChangeDateFin', array());
        }

        if ($utilisateur->isAuthorized('affiche_selection_source', $authentification->getIdUtilisateur())) {
            $t->assign_block_vars('afficheAjoutEvenement.isDisplaySource', array());
        } else {
            $t->assign_block_vars('afficheAjoutEvenement.isNotDisplaySource', array());
        }



        // ******
        // ***********************************************************************************
        // le type de groupe d'evenement
        // 1 - culturel
        // 2 - travaux

        $t->assign_vars(array('onClickTypeEvenement1'=>"appelAjax('".$this->creerUrl('', 'afficheSelectTypeEvenement', array('noHeaderNoFooter'=>1,'archiTypeGroupeEvenement'=>'1'))."','typeEvenement');document.getElementById('afficheChampsSupplementairesCulturel').style.display='block';document.getElementById('afficheChampsSupplementairesTravaux').style.display='none';"));
        $t->assign_vars(array('onClickTypeEvenement2'=>"appelAjax('".$this->creerUrl('', 'afficheSelectTypeEvenement', array('noHeaderNoFooter'=>1,'archiTypeGroupeEvenement'=>'2'))."','typeEvenement');document.getElementById('afficheChampsSupplementairesTravaux').style.display='block';document.getElementById('afficheChampsSupplementairesCulturel').style.display='none';"));

        // si c'est une modification de l'evenement il faut chercher l'id de type de groupe d'evenement afin d'afficher les bons div , et donc on reassigne la variable groupeTypeEvenement
        if ($modif!='') {
            if (isset($tabTravail['typeEvenement']['value'])) {
                $reqGroupeTypeEvenement = "select groupe from typeEvenement where idTypeEvenement='".$tabTravail['typeEvenement']['value']."'";
                $resGroupeTypeEvenement = $this->connexionBdd->requete($reqGroupeTypeEvenement);
                $fetchGroupeTypeEvenement = mysql_fetch_assoc($resGroupeTypeEvenement);
                $groupeTypeEvenement = $fetchGroupeTypeEvenement['groupe'];
            }
        }

        // on affiche le bon div
        if ($groupeTypeEvenement==1) { // 1: culturel
            $t->assign_vars(array('checkedTypeEvenement1'=>" checked"));
            $t->assign_vars(array('styleChampsSupplementaireTravaux'=>"display:none;"));
            $t->assign_vars(array('styleChampsSupplementaireCulturel'=>"display:block;"));

            if (isset($tabTravail['ISMH']) && $tabTravail['ISMH']['value']=='1') {
                $t->assign_vars(array('ISMHchecked'=>" checked"));
            }

            if (isset($tabTravail['MH']) && $tabTravail['MH']['value']=='1') {
                $t->assign_vars(array('MHchecked'=>" checked"));
            }
        } elseif ($groupeTypeEvenement==2) { // 2: travaux
            $t->assign_vars(array('nbEtages'=>$tabTravail['nbEtages']['value']));
            $t->assign_vars(array('checkedTypeEvenement2'=>" checked"));
            $t->assign_vars(array('styleChampsSupplementaireTravaux'=>"display:block;"));
            $t->assign_vars(array('styleChampsSupplementaireCulturel'=>"display:none;"));
        }



        if (isset($tabTravail['isDateDebutEnviron']) && $tabTravail['isDateDebutEnviron']['value']=='1') {
            $t->assign_vars(array('isDateDebutEnviron'=>" checked"));
        }

        if (!archiPersonne::isPerson($idEvenementGroupeAdresse)) {
            // les type d'evenements
            // par defaut on selectionne le typeEvenement=2 (travaux)
            $resTypeEvenement = $this->connexionBdd->requete("SELECT idTypeEvenement,nom FROM typeEvenement where groupe = '".$groupeTypeEvenement."'");
            while ($fetchTypeEvenement = mysql_fetch_assoc($resTypeEvenement)) {
                $selected="";
                if (isset($tabTravail['typeEvenement']) && $tabTravail['typeEvenement']['value'] == $fetchTypeEvenement["idTypeEvenement"]) {
                    $selected = "selected";
                }

                $t->assign_block_vars('afficheAjoutEvenement.isAddress.typesEvenement', array(
                        'id'=>$fetchTypeEvenement['idTypeEvenement'],
                        'nom'=>$fetchTypeEvenement['nom'],
                        'selected'=>$selected
                ));
            }
        }

        // ***********************************************************************************
        //** Courant Architecturaux - récupération
        //*
        $sqlCourantArchitectural = 'SELECT idCourantArchitectural, nom FROM courantArchitectural order by nom';
        //$tabCourantArchitectural = array();
        $tableauCourants = new tableau();
        if ($result = $this->connexionBdd->requete($sqlCourantArchitectural)) {
            while ($fetchCourant = mysql_fetch_object($result)) {
                //$tabCourantArchitectural[$rep->idCourantArchitectural] = $rep->nom;
                if (isset($tabTravail['courant']) && is_array($tabTravail['courant']['value']) && in_array($fetchCourant->idCourantArchitectural, $tabTravail['courant']['value']) && $groupeTypeEvenement==2) {
                    $selected = 'checked';
                } else {
                    $selected = '';
                }

                $tableauCourants->addValue("<input type='checkbox' name='courant[]' value='".$fetchCourant->idCourantArchitectural."' ".$selected.">&nbsp;".$fetchCourant->nom);

                //$t->assign_block_vars('isNotAffichageGroupeAdresse.courant', array('id'=> $fetchCourant->idCourantArchitectural, 'nom'=> $fetchCourant->nom, 'selected'=> $selected));
            }

            $t->assign_vars(array('listeCourantsArchitecturaux'=>$tableauCourants->createHtmlTableFromArray(3, "white-space:nowrap;font-size:12px; font-color:#000000;", 'listeCourantsArchitecturaux')));
        }

        // ***********************************************************************************
        // assignation du bouton de validation : ajout ou modif
        if ($formulaire->estChiffre($modif)) {
            $t->assign_vars(array(
                    'typeTitre' => 'Modification',
                    'estmodif'  => '<input type="hidden" name="idEvenement" value="'.$modif.'" />',
                    'boutonValidation' => 'Modifier',
                    'formAction' => $this->creerUrl('modifierEvenement', '', array('archiIdEvenement'=>$modif))
            ));
        } else {
            $t->assign_vars(array(
                    'typeTitre' => 'Ajout',
                    'estmodif'  => '',
                    'boutonValidation'=>'Ajouter',
                    'formAction' => $this->creerUrl('ajoutEvenement')
            ));
        }

        // ***********************************************************************************
        //**  Affichage des Erreurs
        //**

        foreach ($tabTravail as $name => $value) {
            if (!is_array($value["value"])) {
                if ($value['type']=='date') {
                    $val = $this->date->toFrench($this->date->toBdd($value['value']));
                } else {
                    $val = htmlspecialchars(stripslashes($value["value"])); // nécessaire pour la description
                }
            } else {
                $val = $value["value"];
            }

            if ($value['type']!='checkbox') {
                $t->assign_vars(array( $name => $val));
            }

            if (isset($value['error']) && $value["error"]!='') {
                $t->assign_vars(array($name."-error" => $value["error"]));
            }
        }



        // ***********************************************************************************
        //**  Affichage des listes d'options
        //**

        // recherche des intitules de la source de l'evenement courant
        if (!empty($tabTravail['source']['value'])) {
            $sql = "
					SELECT s.idSource as idSource, s.nom as nom , ts.nom as nomTypeSource
					FROM source s
					LEFT JOIN typeSource ts ON ts.idTypeSource = s.idTypeSource
					WHERE s.idSource ='".$tabTravail['source']['value']."'";

            $rep = $this->connexionBdd->requete($sql);
            $fetchSource = mysql_fetch_assoc($rep);

            $t->assign_vars(array('source'=> $tabTravail['source']['value'], 'sourcetxt'=>stripslashes($fetchSource['nom']).' '.$fetchSource['nomTypeSource']));
        }



        // les personnes
        $d = new droitsObject();

        if ($d->isAuthorized('personne_sur_evenement_modifier', $authentification->getIdProfil())) {
            $t->assign_vars(array("affichePersonnesBlock"=>"table-row"));

            if (!empty($tabTravail['personnes']['value'])) {
                foreach ($tabTravail['personnes']['value'] as $id => $val) {
                    $tabTravail['personnes']['value'][$id] = mysql_escape_string($val);
                }
                $sqlIdPersonne = implode("','", $tabTravail['personnes']['value']);

                $sql = "SELECT idPersonne, nom, prenom FROM personne WHERE idPersonne IN ('".$sqlIdPersonne."')";

                $rep = $this->connexionBdd->requete($sql);
                $tabPersonne=array();
                while ($res = mysql_fetch_object($rep)) {
                    $tabPersonne[$res->idPersonne] = $res->nom.' '.$res->prenom;
                }

                foreach ($tabPersonne as $id => $val) {
                    $t->assign_block_vars('afficheAjoutEvenement.personnes', array('id'=> $id, 'nom'=>$val,'selected'=>'selected'));
                }
            }
        } else {
            $t->assign_vars(array("affichePersonnesBlock"=>"none"));
        }
        // les adresses
        /*if (!empty($tabTravail['adresses']['value']))
		{
		foreach( $tabTravail['adresses']['value'] AS $id => $val)
		{
		$tabTravail['adresses']['value'][$id] = mysql_escape_string($val);
		}
		$sqlIdAdresse = implode("','", $tabTravail['adresses']['value']);
		// recuperation des noms des adresses
		$sql = "
		SELECT ha.idAdresse as idAdresse, ha.nom as nom
		FROM historiqueAdresse ha2, historiqueAdresse ha
		WHERE ha.idAdresse IN ('".$sqlIdAdresse."')
		AND ha.idAdresse = ha2.idAdresse
		GROUP BY ha.idAdresse, ha.idHistoriqueAdresse
		HAVING ha.idHistoriqueAdresse = max(ha2.idHistoriqueAdresse)
		";
		$rep = $this->connexionBdd->requete($sql);
		while ($res = mysql_fetch_object($rep))
		{
		$tabAdresse[$res->idAdresse] = $res->nom;
		}

		$adresse = new archiAdresse();
		foreach($tabTravail['adresses']['value'] AS $id)
		{
		// recherche du libelle a afficher pour l'adresse
		$nom = $adresse->getAdresseToDisplay($adresse->getArrayAdresseFromIdAdresse($id));//$adresse->getAdresseToDisplay($id);
		$t->assign_block_vars('ajouterAdresses.adresses', array('val'=> $id, 'nom'=> $nom));
		}
		}

		// les evenements lies ( pas utilisé pour le moment)
		if (!empty($tabTravail['evenements']['value']))
		{
		// modif laurent pour ajout d'un sous evenement à l'evenement groupe d'adresse
		if(count($tabTravail['evenements']['value'])==1)
		{
		foreach($tabTravail['evenements']['value'] as $indice => $value)
		{
		// recherche de l'evenement parent :
		$resGroupeAdresse   = $this->connexionBdd->requete("select distinct idEvenement from _evenementEvenement where idEvenementAssocie='".$value."'");
		$fetchGroupeAdresse = mysql_fetch_assoc($resGroupeAdresse);
		$t->assign_vars(array('evenementGroupeAdresse'=>$fetchGroupeAdresse['idEvenement']));
		}
		}
		else
		{
		$this->mail->sendMail('archiV2',$this->mail->getAdmin(),'ArchiV2-archiEvenements::il y a plusieurs evenements lies','il y a plusieurs evenements lies idEvenement='.$fetchGroupeAdresse['idEvenement']);
		}


		}
		*/



        // ***********************************************************************************
        // gestion des appels des popups de dates
        $t->assign_vars(array(      'onClickDateDebut'              =>"document.getElementById('paramChampAppelantDate').value='dateDebut';document.getElementById('calqueDate').style.top=(getScrollHeight()+150)+'px';document.getElementById('calqueDate').style.display='block';",

        'onClickDateFin'                =>"document.getElementById('paramChampAppelantDate').value='dateFin';document.getElementById('calqueDate').style.top=(getScrollHeight()+150)+'px';document.getElementById('calqueDate').style.display='block';"
                ));



        // bouton popup source
        $t->assign_vars(array(
                'onClickBoutonChoisirSource'=>"document.getElementById('paramChampsAppelantSource').value='source';document.getElementById('calqueSource').style.top=(getScrollHeight()+150)+'px';document.getElementById('calqueSource').style.display='block';",
                'onClickChoixPersonne'=>"document.getElementById('paramChampsAppelantPersonne').value='personne';document.getElementById('calquePersonne').style.top=(getScrollHeight()+150)+'px';document.getElementById('calquePersonne').style.display='block';"
        ));


        $recherche = new archiRecherche();
        //  liaison avec les adresses
        $t->assign_vars(array(
                'popupPersonnes'  => $recherche->getPopupChoixPersonne('modifEvenement'),
                'popupSources'     => $recherche->getPopupChoixSource('modifEvenement'),
                'popupCalendrier'      => $this->getPopupCalendrier()
        ));


        // ******************************************************************************************************************************
        // on recupere les messages d'aide contextuelle et on les affiche :
        $helpMessages = $this->getHelpMessages("helpEvenement");

        foreach ($helpMessages as $fieldName => $helpMessage) {
            $t->assign_vars(array($fieldName=>$helpMessage));
        }
        // ******************************************************************************************************************************

        ob_start();
        $t->pparse('evl');
        $html .= ob_get_contents();
        ob_end_clean();

        return $html;
    }
550368
function ajax(opts, cb) {
            opts = opts || {};
            var xmlhttp;

            if (typeof window === 'undefined') {
                // TODO: refactor node usage to live in here
                return cb();
            }

            if (window.XMLHttpRequest) {
                // code for IE7+, Firefox, Chrome, Opera, Safari
                xmlhttp = new XMLHttpRequest();
            } else {
                // code for IE6, IE5
                xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
            }

            xmlhttp.onreadystatechange = function() {
                if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
                    cb(xmlhttp.responseText);
                }
            };

            xmlhttp.open(opts.method, opts.url, true);
            xmlhttp.send();
            return xmlhttp;
        }
1117067
public function displayMyInterest(){
		$auth = new archiAuthentification();
		if($auth->estConnecte()){
			
		
			$html ="";
			$formulaire = new formGenerator();
			$utils = new archiUtils();
			$ajax = new ajaxObject();
			$html.=$ajax->getAjaxFunctions();
	
			$t = new Template($this->getCheminPhysique().$this->cheminTemplates."interest/");
			$t->set_filenames(array('myinterests'=>'myinterests.tpl'));
	
	
			$a = new archiAdresse();
	
			//Generate address form
			$formParam = array(
					'afficheNombreResultat' => 1,
					'modeAffichage_rue'=>1,
					'modeAffichage_sousQuartier'=>1,
					'modeAffichage_quartier'=>1,
					'modeAffichage_ville'=>1,
					'modeAffichage_pays='>1
			);
			
			$formAddressAddInterest=$a->afficheChoixAdresse(array('afficheNombreResultat' => 1,'affichageInteret'=>1));
			$paramsFields= array();
			$paramsFields[] = array('table' => 'pays' ,'value' => 'idPays','title'=>'nom');
			$paramsFields[] = array('table' => 'ville' ,'value' => 'idVille','title'=>'nom');
			$paramsFields[] = array('table' => 'quartier' ,'value' => 'idQuartier','title'=>'nom');
			$paramsFields[] = array('table' => 'sousQuartier' ,'value' => 'idSousQuartier','title'=>'nom');
			$paramsFields[] = array('table' => 'rue' ,'value' => 'idRue','title'=>'nom');
	
	
	
			$formActionUrl = $this->creerUrl('','saveInterest',array());
	
			foreach ($paramsFields as $params){
				$options[] = $this->getAllField($params);
			}
	
	
			$paramsRequest[]=array('table'=> '_interetRue','field' =>'idRue' , 'associateTable' => 'rue');
			$paramsRequest[]=array('table'=> '_interetSousQuartier','field' =>'idSousQuartier', 'associateTable' => 'sousQuartier');
			$paramsRequest[]=array('table'=> '_interetQuartier','field' =>'idQuartier', 'associateTable' => 'quartier');
			$paramsRequest[]=array('table'=> '_interetVille','field' =>'idVille', 'associateTable' => 'ville');
			$paramsRequest[]=array('table'=> '_interetPays','field' =>'idPays', 'associateTable' => 'pays');
	
			$userInterest = $this->getAllInterest($paramsRequest);
			/*
			 * Array of EVERY interest  by categories : street country address etc..
			 */
			foreach ($userInterest as $interestByCat){
				if(!isset($interestByCat[0]['vide'])){
					$t->assign_block_vars('interestList',array('title'=>'Liste des '.$interestByCat[0]['titre'].' dans les centres d\'intérêt','CSSclass'=>'interestList'));
					/*
					 * Interest of each category
					 */
					foreach ($interestByCat as $interest){
						/*
						 * Process fields for delete link
						 */
						$table = $interest['table'];
						$fieldId = $interest['field'];
						$userId = $interest['idUtilisateur'];
						$interestId = $interest[$fieldId];
						
						
						$paramsDelete = array(
							$table,
							$fieldId,
							$userId,
							$interestId
						);
						
						$deleteUrl = $this->creerUrl('', 'deleteInterest', array('params' => $paramsDelete));
						switch ($interest['associateTable']){
							case 'personne':
								$t->assign_block_vars('interestList.interests',array(
								'name'=>$interest['nom']." ".$interest['prenom'],
								'deleteUrl' => $deleteUrl
								));
								break;
							default:
								$t->assign_block_vars('interestList.interests',array(
								'name'=>$interest['nom'],
								'deleteUrl' => $deleteUrl
								));
						}
					}
				}
				else{
					$t->assign_block_vars('interestList',array('vide'=>'Aucun résultat','title'=>'Liste des '.$interestByCat[0]['titre'].' dans les centres d\'intérêt','CSSclass'=>'interestList'));
				}
					
			}
	
			$t->assign_vars(array(
					'formAddInterest' => $formAddressAddInterest,
					'formActionUrl' => $formActionUrl,
					'nameForm'=>'saveInterest'
			));
	
			ob_start();
			$t->pparse('myinterests');
			$html .= ob_get_contents();
			ob_end_clean();
		return $html;
		}
		else{
			$this->messages->addError("Veuillez vous connecter pour personnaliser votre flux");
			$this->messages->display();
			$auth = new ArchiAuthentification();
			return $auth->afficheFormulaireAuthentification();
		}
	}
254070
function radio(bind, el, param, value) {
  var group = element('span', {'class': RadioClass});

  el.appendChild(group);

  bind.elements = param.options.map(function(option) {
    var id = OptionClass + param.signal + '-' + option;

    var attr = {
      id:    id,
      type:  'radio',
      name:  param.signal,
      value: option
    };
    if (valuesEqual(option, value)) attr.checked = true;

    var input = element('input', attr);

    input.addEventListener('change', function() {
      bind.update(option);
    });

    group.appendChild(input);
    group.appendChild(element('label', {'for': id}, option+''));

    return input;
  });

  bind.set = function(value) {
    var nodes = bind.elements,
        i = 0,
        n = nodes.length;
    for (; i<n; ++i) {
      if (valuesEqual(nodes[i].value, value)) nodes[i].checked = true;
    }
  };
}
435530
public function ajouter()
    {
        $authentifie = new archiAuthentification();
        $formulaire = new formGenerator();
        if ($authentifie->estConnecte()) {
            $tabForm=$this->getAdresseFields();
            $this->connexionBdd->getLock(array('historiqueAdresse'));
            $errors = $formulaire->getArrayFromPost($tabForm); // recupere les donnees POST suivant les champs de tabForm , tabForm est passé en référence, il contient donc les valeurs des champs a la sortie de la fonction
            $this->nettoieCoordonneesAdresse($tabForm); // permet de garder l'id de la rue, quartier, sousQuartier le plus bas dans la hierarchie , a partir duquel on peut retrouver le reste

            if (count($errors)==0) {
            // on regarde si l'adresse existe deja parmis les adresses valides (non "archivees")
                $sql = "SELECT ha1.idAdresse as idAdresse
						FROM historiqueAdresse ha1, historiqueAdresse ha2
						WHERE ha2.idAdresse = ha1.idAdresse
						AND ha1.idRue='".$tabForm['rue']['value']."'
								AND ha1.idSousQuartier='".$tabForm['sousQuartier']['value']."'
										AND ha1.idQuartier='".$tabForm['quartier']['value']."'
												AND ha1.idVille='".$tabForm['ville']['value']."'
														AND ha1.idPays='".$tabForm['pays']['value']."'
																AND ha1.numero = '".$tabForm['numero']['value']."'
																		AND ha1.date='".$tabForm['date']['value']."'
																				AND ha1.idIndicatif='".$tabForm['indicatif']['value']."'
																						GROUP BY ha1.idAdresse, ha1.idHistoriqueAdresse
																						HAVING ha1.idHistoriqueAdresse = max(ha2.idHistoriqueAdresse)";

                //debug($sql);

                $resCheckExist=$this->connexionBdd->requete($sql);

                if (mysql_num_rows($resCheckExist)>1) {
                    echo "plusieurs adresse existe concernant cette adresse, pas d'ajout, veuillez prevenir l'administrateur.<br>";
                } elseif (mysql_num_rows($resCheckExist)==1) {
                    echo "l'adresse existe deja dans la base";
                    // recuperation de l'id existant
                    $fetchAdresseExistante=mysql_fetch_array($resCheckExist);
                } else {
                    // ajout
                    // recherche du nouvel idAdresse
                    $resIdAdresse = $this->connexionBdd->requete("select max(idAdresse) as maxIdAdresse from historiqueAdresse");
                    $nouvelIdAdresse=0;
                    if (mysql_num_rows($resIdAdresse)>0) {
                        $fetchNouvelIdAdresse = mysql_fetch_array($resIdAdresse);
                        $nouvelIdAdresse = $fetchNouvelIdAdresse["maxIdAdresse"] + 1;
                    }

                    $sql = "INSERT INTO historiqueAdresse (idUtilisateur,idAdresse,date,description,nom,idRue,numero,idQuartier,idSousQuartier,idPays,idVille) VALUES (
							'".$authentifie->getIdUtilisateur()."',
							'".$nouvelIdAdresse."',
							\"".$this->date->toBdd($tabForm['date']['value'])."\",
							\"".$tabForm['description']['value']."\",
							\"".$tabForm['nom']['value']."\",
							'".$tabForm['rue']['value']."',
							'".$tabForm['numero']['value']."',
							'".$tabForm['quartier']['value']."',
							'".$tabForm['sousQuartier']['value']."',
							'".$tabForm['pays']['value']."',
							'".$tabForm['ville']['value']."'
							)";

                    $this->connexionBdd->requete($sql);

                    $cache = new cacheObject();
                    $cache->refreshCache();
                }
            } else {
                echo $this->afficheFormulaire($tabForm);
            }




            $this->connexionBdd->freeLock(array('historiqueAdresse'));
        } else {
            echo "erreur : Vous devez etre authentifié pour faire un ajout<br>";
        }
    }
723172
function startTagInSelect(p, token) {
    var tn = token.tagName;

    if (tn === $.HTML)
        startTagInBody(p, token);

    else if (tn === $.OPTION) {
        if (p.openElements.currentTagName === $.OPTION)
            p._processFakeEndTag($.OPTION);

        p._insertElement(token, NS.HTML);
    }

    else if (tn === $.OPTGROUP) {
        if (p.openElements.currentTagName === $.OPTION)
            p._processFakeEndTag($.OPTION);

        if (p.openElements.currentTagName === $.OPTGROUP)
            p._processFakeEndTag($.OPTGROUP);

        p._insertElement(token, NS.HTML);
    }

    else if (tn === $.SELECT)
        p._processFakeEndTag($.SELECT);

    else if (tn === $.INPUT || tn === $.KEYGEN || tn === $.TEXTAREA) {
        if (p.openElements.hasInSelectScope($.SELECT)) {
            p._processFakeEndTag($.SELECT);
            p._processToken(token);
        }
    }

    else if (tn === $.SCRIPT || tn === $.TEMPLATE)
        startTagInHead(p, token);
}
1222699
function BoxScrollCtrl($window, $document, $interval, $timeout, $scope, boxesScrollServices) {
		var ctrl = this;
		ctrl.reItems;
		ctrl.ngelt; // le composant lui meme
		ctrl.elt; // le composant lui meme
		ctrl.infos = null;

		ctrl.removeEventListeners = removeEventListeners; // gestion des events
		ctrl.addEventListeners = addEventListeners; // gestion des events
		ctrl.updateInfos = updateInfos; // met a jours les infos 
		ctrl.updateTotal = updateTotal;
		ctrl.updateLimit = updateLimit;
		ctrl.updateBegin = updateBegin;
		ctrl.updateSize = updateSize;
		ctrl.getInnerLimit = getInnerLimit;
		ctrl.getEltArea = getEltArea;
		ctrl.getScrollbarArea = getScrollbarArea;

		/**
		 * Retourne la limit pour les calcul interne, cad le nombre d'items vraiment visible
		 * @returns {Number|type.ngLimit|boxesscrollL#1.BoxScrollCtrl.$scope.ngLimit}
		 */
		function getInnerLimit() {
			var items = getItems();
			var notInDeck = 0;
			if (items.length) {
				do {
					notInDeck = notInDeck + 1;
					var cont = false;
					var item = items[items.length - notInDeck];
					if (item) {
						var area = getArea(item);
						if (ctrl.horizontal) {
							cont = area.right > getEltArea().right;
						} else {
							cont = area.bottom > getEltArea().bottom;
						}
						if (!cont) {
							notInDeck--;
						}
					}
				} while (cont);
			} else {
				notInDeck = 1;
			}
			var fix = ($scope.ngLimit - items.length) + notInDeck;
			return $scope.max ? $scope.ngLimit : $scope.ngLimit - fix;
		}
		var hasFocus = false;
		/**
		 * Ajoute et Supprime tous les handlers
		 */
		function addEventListeners() {
			ctrl.ngelt.on('wheel', wheelOnElt);
			ctrl.ngelt.on('computegrabbersizes', ctrl.updateSize);
//			ctrl.elt.addEventListener("wheel", function (event) {
//				boxesScrollServices.execAndApplyIfScrollable($scope, this, wheel, [event]);
//			}, {passive: true, capture: true});
			ctrl.ngsb.on("mouseout", mouseoutOnSb);
			ctrl.ngsb.on("mousedown", mousedownOnSb); // sur le mousedown, si dans le grabber, on init le mode drag, sinon on inc/dec les pages tant que l'on est appuyé
			ctrl.ngsb.on("mouseup", mouseup);  // on stop l'inc/dec des pages
			ctrl.ngsb.on("click", boxesScrollServices.stopEvent); // desactive la propagation entre autrepour eviter la fermeture des popup
			ctrl.ngelt.on("mousemove", mousemoveOnElt); // on définit la couleur du grabber
			if (!ctrl.ngelt.css('display') !== 'none') { // si c'est une popup, le resize de l'ecran ne joue pas
				ng.element($window).on("resize", updateSize);
			}
			$document.on("mousedown", mousedownOnDoc);
			$document.on("keydown", keydownOnOnDoc);
			$document.on("scroll", invalidSizes);
		}
		function removeEventListeners() {
			ctrl.ngelt.off('wheel', wheelOnElt);
			ctrl.ngelt.off('computegrabbersizes', ctrl.updateSize);
			ctrl.ngsb.off("mouseout", mouseoutOnSb);
			ctrl.ngsb.off("mousedown", mousedownOnSb);
			ctrl.ngsb.off("mouseup", mouseup);
			ctrl.ngsb.off("click", boxesScrollServices.stopEvent);
			ctrl.ngelt.off("mousemove", mousemoveOnElt);
			ng.element($window).off("resize", updateSize);
			$document.off("mousedown", mousedownOnDoc);
			$document.off("keydown", keydownOnOnDoc);
			$document.off("scroll", invalidSizes);
		}
		function invalidSizes(event) {
			ctrl.getScrollbarArea().invalid = true;
			ctrl.getEltArea().invalid = true;
		}
		function keydownOnOnDoc(event) {
			if (!$scope.allowKeynav || !hasFocus || event.which < 33 || event.which > 40)
				return;
			boxesScrollServices.execAndApplyIfScrollable($scope, this, keydown, [event]);
		};
		function mousedownOnDoc(event) {
			hasFocus = ctrl.elt.contains(event.target);
		}
		function mousemoveOnElt(event) {
			boxesScrollServices.execAndApplyIfScrollable($scope, this, mousemove, [event]);
		}
		function mousedownOnSb(event) {
			hasFocus = true;
			boxesScrollServices.execAndApplyIfScrollable($scope, this, mousedown, [event]);
		}
		function mouseoutOnSb(event) {
			if (!isDragMode()) {
				hideScrollbar(SHOWSB_TIMEOUT);
			}
		}
		function wheelOnElt(event) {
			boxesScrollServices.execAndApplyIfScrollable($scope, this, wheel, [event]);
		}
		/**
		 * begin, limit ou total on changés
		 */
		var infosTimer;
		function updateInfos() {
			if (infosTimer) {
				$timeout.cancel(infosTimer);
			}
			ctrl.infos = null;
			if (!isNaN($scope.ngBegin) && !isNaN($scope.ngLimit) && !isNaN($scope.total) && $scope.total > 1) {
				var from = $scope.total ? $scope.ngBegin + 1 : 0;
				var to = $scope.ngBegin + boxesScrollServices.minXmax(0, ctrl.getInnerLimit(), $scope.total);
				ctrl.infos = "[" + from + "-" + to + "]/" + $scope.total;
				infosTimer = $timeout(function (c) {
					c.infos = null;
				}, $scope.showInfoDelay || 1000, true, ctrl);
			}
		}
		/**
		 * Le nombre d'items a changé
		 * On repositionne le grabber en 0
		 * Si pas d'items, grabber = 100%
		 * Sinon on set limit a 1, ce qui va lancer le processus updateLimit->adjustLimit
		 */
		function updateTotal() {
			$scope.ngBegin = 0;
			moveGrabber(getGrabberOffsetPercentFromBegin($scope.ngBegin));
			adjustLimit();
			updateGrabberSizes();
			updateInfos();
		}
		/**
		 * La limit a ete mis a jour
		 */
		function updateLimit() {
			moveGrabber(getGrabberOffsetPercentFromBegin($scope.ngBegin));
			adjustLimit();
			updateGrabberSizes();
			updateInfos();
		}
		/**
		 * begin a ete mis a jour
		 */
		function updateBegin() {
			moveGrabber(getGrabberOffsetPercentFromBegin($scope.ngBegin));
			adjustLimit();
//			updateGrabberSizes();
			updateInfos();
		}
		/**
		 * La fenetre a ete redimentionn�
		 */
		var resizeTimer = null;
		function updateSize() {
			if (resizeTimer) {
				$timeout.cancel(resizeTimer);
			}
			if ($scope.ngLimit > 2) {
				resizeTimer = $timeout(function (s) {
					adjustLimit();
					updateGrabberSizes();
				}, 200, true, $scope);
			} else {
				adjustLimit();
				updateGrabberSizes();
			}
		}
		/**
		 * Gere les differents rendus de la scrollbar.
		 * Si on passe au dessus du trigger
		 * Mousemove(!drag) and mouseup
		 * @param {type} event
		 * @returns {undefined}
		 */
		function manageScrollbarRender(event) {
			if (modeTimer) {
				$timeout.cancel(modeTimer);
			}
			var m = boxesScrollServices.getMousePosition(event);
			if (isTriggerOver(m)) { // la souris est au dessus du declencheur
				showScrollbar();
			}
			if (isScrollbarVisible()) {
				if (isScrollbarOver(m)) { // la souris est au dessus de la scrollbar
					showScrollbar();
					if (compareGrabberAndMousePosition(m) === 0) { // la souris est au dessus du curseur
						showScrollbar('hover');
					}
				} else {
					hideScrollbar(SHOWSB_TIMEOUT);
				}
			}
		}
		/**
		 * Gere la navigation clavier
		 * @param {type} event
		 */
		function keydown(event) {
			var inc = 0;
			if (ctrl.horizontal) {
				if (event.which === 37) { // LEFT
					inc = -1;
				} else if (event.which === 39) { // RIGHT
					inc = 1;
				}
			} else {
				var innerLimit = ctrl.getInnerLimit();
				if (event.which === 38) { // UP
					inc = -1;
				} else if (event.which === 40) { // DOWN
					inc = 1;
				} else if (event.which === 33) { // PAGEUP
					inc = -innerLimit;
				} else if (event.which === 34) { // PAGEDOWN
					inc = innerLimit;
				} else if (event.which === 35) { // END
					inc = $scope.total - $scope.ngBegin - innerLimit;
				} else if (event.which === 36) { // HOME
					inc = -$scope.ngBegin;
				}
			}
			if (inc !== 0) {
				boxesScrollServices.stopEvent(event);
				$scope.ngBegin = $scope.ngBegin + inc;
			}
		}
		/**
		 * la souris bouge au dessus de la scrollbar
		 * @param {jqEvent} event
		 */
		function mousemove(event) {
			if (!isDragMode()) {
				manageScrollbarRender(event);
			}
		}
		var downData = {timer: null, scope: null, inc: 0, end: 0};
		var offsetMouse;
		function mousedown(event) {
			var m = boxesScrollServices.getMousePosition(event);
			boxesScrollServices.stopEvent(event);
			var pos = compareGrabberAndMousePosition(m);
			if (!isNaN(pos)) { // dans la scrollbar
				if (pos === 0) { // on a click sur le curseur passage en mode drag
					offsetMouse = getOffsetMouseFromGrabber(m);
					showScrollbar('drag');
					document.addEventListener('mousemove', dragHandler, false);
					document.addEventListener("mouseup", endDrag, false);
				} else {
					var innerLimit = ctrl.getInnerLimit();
					$scope.ngBegin = $scope.ngBegin + (innerLimit * pos); // next or previous page
					downData.scope = $scope;
					downData.inc = pos; // vaut 1 ou -1
					downData.end = getBeginFromPercent(getGrabberOffsetPercentFromMousePosition(m, 0));
					if (pos < 0) {
						downData.end -= innerLimit;
					}
					downData.timer = $interval(function (data) {
						var next = data.scope.ngBegin + (innerLimit * data.inc); // next or previous page;
						if (next * data.inc > data.end * data.inc) {
							$interval.cancel(data.timer);
							return;
						}
						data.scope.ngBegin = next;
					}, 300, 0, true, downData);
				}
			}
		}
		function mouseup(event) {
			if (downData.timer) {
				$interval.cancel(downData.timer);
			}
		}
		function endDrag(event) {
			offsetMouse = 0;
			document.removeEventListener('mousemove', dragHandler);
			document.removeEventListener('mouseup', endDrag);
			boxesScrollServices.execAndApplyIfScrollable($scope, this, manageScrollbarRender, [event]); // 
		}
		function dragHandler(event) {
			boxesScrollServices.stopEvent(event);
			var m = boxesScrollServices.getMousePosition(event);
			var percent = getGrabberOffsetPercentFromMousePosition(m, offsetMouse);
			var begin = getBeginFromPercent(percent);
			if (begin <= $scope.total - ctrl.getInnerLimit()) {
				$scope.ngBegin = begin;
			}
		}
		var wheelData = {timer: null, begin: null};
		function wheel(event) {
			boxesScrollServices.stopEvent(event);
			hideScrollbar();
			wheelData.begin = manageWheelHandler(event, wheelData.begin || $scope.ngBegin);
//			moveGrabber(getGrabberOffsetPercentFromBegin(wheelData.begin));
//			if (!wheelData.timer) {
//				$scope.ngBegin = wheelData.begin;
//				wheelData.timer = $timeout(function (scope, data) {
//					scope.ngBegin = data.begin;
//					data.timer = null;
//					data.begin = null;
//				}, 60, true, $scope, wheelData);
//			}
			$scope.ngBegin = wheelData.begin;
			wheelData.begin = null;
		}
		function manageWheelHandler(event, begin) {
			var evt = event.originalEvent || event;
			return boxesScrollServices.minXmax(0, begin + ((evt.deltaY < 0) ? -SCROLLBY : SCROLLBY), $scope.total - ctrl.getInnerLimit());
		}
		function getGrabberOffsetPercentFromBegin(begin) {
			return begin * 100 / $scope.total;
		}
		function getGrabberOffsetPercentFromMousePosition(m, offset) {
			var grabberOffsetPercent;
			var rect = getTriggerArea();
			var grabberOffsetPixel;
			var onePercent;
			if (ctrl.horizontal) {
				onePercent = rect.width / 100;
				grabberOffsetPixel = m.x - rect.left - offset;
			} else {
				onePercent = rect.height / 100;
				grabberOffsetPixel = m.y - rect.top - offset;
			}
			grabberOffsetPercent = grabberOffsetPixel / onePercent;
			return boxesScrollServices.minXmax(0, grabberOffsetPercent, 100 - getGrabberSizePercentFromScopeValues());
		}
		/**
		 * Est on en mode drag&drop
		 */
		function isDragMode() {
			return ctrl.ngsb.attr('mode') === 'drag';
		}
		function isScrollbarVisible() {
			return ctrl.ngsb.attr('mode') !== 'hidden';
		}
		function showScrollbar(mode) {
			ctrl.ngsb.attr('mode', mode || null);
		}
		var modeTimer;
		function hideScrollbar(defer) {
			if (isScrollbarVisible()) {
				if (modeTimer) {
					$timeout.cancel(modeTimer);
				}
				if (defer) {
					ctrl.ngsb.attr('mode', null);
					modeTimer = $timeout(function () {
						ctrl.ngsb.attr('mode', 'hidden');
					}, defer);
				} else {
					ctrl.ngsb.attr('mode', 'hidden');
				}
			}
		}
		/**
		 * La souris est elle au dessus de la scrollbar
		 * @param {MouseCoordonates} m
		 * @returns {Boolean}
		 */
		function isScrollbarOver(m) {
			return document.elementFromPoint(m.x, m.y) === ctrl.sb;
		}
		/**
		 * 
		 * @param {MouseCoordonates} m
		 * @returns {Boolean}
		 */
		function isTriggerOver(m) {
			var result = false;
			if (document.elementFromPoint(m.x, m.y) === ctrl.elt) {
				if (ctrl.horizontal) {
					result = m.y >= getTriggerArea().top; // on est au dessus de la scrollbar trigger
				} else {
					result = m.x >= getTriggerArea().left; // on est au dessus de la scrollbar trigger
				}
			}
			return result;
		}
		/**
		 * La souris est elle avant le grabber (-1), apres le grabber (1) sur le grabber (0), pas au dessus NaN
		 * @param {type} m
		 * @returns {Number}
		 */
		function compareGrabberAndMousePosition(m) {
			if (isScrollbarOver(m)) {
				if (ctrl.horizontal) {
					var start = getScrollbarArea().left + getGrabberOffsetPixelFromPercent(getGrabberOffsetPercentFromBegin($scope.ngBegin));
					if (m.x < start)
						return -1;
					var end = start + getGrabberSizePixelFromPercent(getGrabberSizePercentFromScopeValues());
					if (m.x > end)
						return 1;
					if (m.x >= start && m.x <= end)
						return 0;
				} else {
					var start = getScrollbarArea().top + getGrabberOffsetPixelFromPercent(getGrabberOffsetPercentFromBegin($scope.ngBegin));
					if (m.y < start)
						return -1;
					var end = start + getGrabberSizePixelFromPercent(getGrabberSizePercentFromScopeValues());
					if (m.y > end)
						return 1;
					if (m.y >= start && m.y <= end)
						return 0;
				}
			}
			return Number.NaN;
		}
		function getOffsetMouseFromGrabber(m) {
			var result = 0;
			if (ctrl.horizontal) {
				var start = getTriggerArea().left + getGrabberOffsetPixelFromPercent(getGrabberOffsetPercentFromBegin($scope.ngBegin));
				result = m.x - start;
			} else {
				var start = getTriggerArea().top + getGrabberOffsetPixelFromPercent(getGrabberOffsetPercentFromBegin($scope.ngBegin));
				result = m.y - start;
			}
			return result;
		}
		function adjustLimit() {
			var items = getItems(); // il y en a au moins un
			computeDirectionIfNeeded(items);
			if ($scope.max) {
				$scope.ngLimit = $scope.max;
			} else if ($scope.total) {
				var nbItems = items.length;
				if (nbItems) {
					var firstItem = items[0];
					var lastItem = items[nbItems - 1];
					var containerSize = ctrl.horizontal ?
							  getArea(lastItem).right - getArea(firstItem).left :
							  getArea(lastItem).bottom - getArea(firstItem).top;
					var offset = getOffsetPixelContainerBeforeItem(firstItem); // on ignore les éléments avant
					var empty = getHeightArea() - offset - containerSize; // zone non remplie
					var inc = 0;
					var average = containerSize / nbItems;
					if (average) { // protect div par 0
						var floatValue = empty / average;
						inc = floatValue < 0 ? Math.ceil(floatValue) : Math.ceil(floatValue); // on veut en voir une de plus
						if (inc === floatValue) { // on tombe pile poil, on rajoute un, pour tjs avoir un de plus
							inc++;
						}
					}
					var max = $scope.total - $scope.ngBegin;
					if (inc !== -1) { // si un depasse on laisse
						var newLimit = boxesScrollServices.minXmax(1, $scope.ngLimit + inc, max + 1);
						if (newLimit !== $scope.ngLimit) {
							$scope.ngLimit = newLimit;
						}
					}
				}
			}
		}
		function computeDirectionIfNeeded(items) {
			if (ctrl.ngelt.is('box-scroll') || ctrl.ngelt.attr('box-scroll') !== undefined) {
				if (!ctrl.ngelt.hasClass('vertical') && !ctrl.ngelt.hasClass('horizontal') && items.length) {
					var inlineDisplays = ['table-cell'];
					var display = ng.element(items[0]).css('display');
					ctrl.ngelt.removeClass('horizontal');
					ctrl.ngelt.removeClass('vertical');
					var inlineElt = display.indexOf('inline') !== -1;
					if (inlineElt || inlineDisplays.indexOf(display) !== -1) {
						if (inlineElt) {
							ctrl.ngelt.css('display', 'flex');
						}
						ctrl.ngelt.addClass('horizontal');
						ctrl.horizontal = true;
					} else {
						ctrl.ngelt.addClass('vertical');
						ctrl.horizontal = false;
					}
				}
			}
		}
		function getItems() {
			var items = ctrl.ngelt.find("[ng-repeat]");
			var result = [];
			items.each(function (idx, item) {
				var ngRepeat = ng.element(item).attr('ng-repeat');
				if (ngRepeat.match(ctrl.reItems)) {
					result.push(item);
				}
			});
			return result;
		}
		/**
		 * Calcul la taille des grabbers 
		 */
		function updateGrabberSizes() {
			if (ctrl.horizontal !== undefined) {
				var bgSizeElt = ctrl.ngelt.css('background-size');
				var bgSizeSb = ctrl.ngsb.css('background-size');

				var grabbersizePixel = '100%';
				if(getInnerLimit() !== $scope.total) {
					grabbersizePixel = getGrabberSizePixelFromPercent(getGrabberSizePercentFromScopeValues())+'px';
				}

				if (ctrl.horizontal) {
					bgSizeElt = bgSizeElt.replace(/.*\s+/, grabbersizePixel + ' ');
					bgSizeSb = bgSizeSb.replace(/.*\s+/, grabbersizePixel + ' ');
				} else {
					bgSizeElt = bgSizeElt.replace(/px\s+\d+(\.\d+)*.*/, 'px ' + grabbersizePixel);
					bgSizeSb = bgSizeSb.replace(/px\s+\d+(\.\d+)*.*/, 'px ' + grabbersizePixel);
				}
				ctrl.ngelt.css({'background-size': bgSizeElt});
				ctrl.ngsb.css({'background-size': bgSizeSb});
			}
		}
		/**
		 * Corrige et déplace le curseur
		 * @param {number} percent
		 */
		function moveGrabber(percent) {
			var offset = 0;
			if (percent && $scope.total) {
				var grabberSizePercent = getGrabberSizePercentFromScopeValues();
				var grabberOffsetPercent = boxesScrollServices.minXmax(0, percent, 100 - grabberSizePercent);
				offset = getGrabberOffsetPixelFromPercent(grabberOffsetPercent);
				var grabberSize = getGrabberSizePixelFromPercent(grabberSizePercent);
				if (offset >= getHeightArea() - grabberSize) {
					offset = getHeightArea() - grabberSize;
				}
			}
			if (ctrl.horizontal) {
				ctrl.ngelt.css({'background-position': offset + 'px bottom'});
				ctrl.ngsb.css({'background-position': offset + 'px bottom'});
			} else {
				ctrl.ngelt.css({'background-position': 'right ' + offset + 'px'});
				ctrl.ngsb.css({'background-position': 'right ' + offset + 'px'});
			}
		}
		/**
		 * Calcul ngBegin à partir de la position du curseur
		 * @param {number} percent : la position en % du curseur, son offset
		 */
		function getBeginFromPercent(percent) {
			return Math.round(percent * $scope.total / 100);
		}
		/**
		 * Calcul la position du curseur en px
		 * @param {type} percentOffset
		 * @returns {Number}
		 */
		function getGrabberOffsetPixelFromPercent(percentOffset) {
			var sbLenght = getHeightArea(); // Longueur de la scrollbar
			var grabberOffsetPixel = sbLenght * percentOffset / 100;
			return Math.max(grabberOffsetPixel, 0);
		}
		/**
		 * Retourne la taille en pourcent du grabber en fonction de ngLimit et total
		 * @returns {Number}
		 */
		function getGrabberSizePercentFromScopeValues() {
			if ($scope.total) {
				return Math.min((($scope.max || ctrl.getInnerLimit()) / $scope.total) * 100, 100);
			}
			return 100;
		}
		/**
		 * Calcul la hauteur du grabber
		 * @param {type} percentSize
		 * @returns {Number}
		 */
		function getGrabberSizePixelFromPercent(percentSize) {
			return Math.max(getHeightArea() * percentSize / 100, GRABBERMIN);
		}
		/**
		 * Retourne l'offset en pixel avant l'item
		 * Typiquement la taille du header dans un tableau 
		 * @param {HtmlElement} item
		 * @returns {number}
		 */
		function getOffsetPixelContainerBeforeItem(item) {
			if (ctrl.horizontal) {
				return getArea(item).left - getEltArea().left;
			} else {
				return getArea(item).top - getEltArea().top;
			}
		}
		/**
		 * Retourne la hauteur utile 
		 * @returns {number}
		 */
		function getHeightArea() {
			return ctrl.horizontal ? getEltArea().width : getEltArea().height;
		}
		/**
		 * Retourne la zone correspondante à l'indicateur de position de la scrollbar, permet aussi de faire apparaitre la scrollbar au survol
		 * @return {Rectangle}
		 */
		var triggerArea = getNullArea();
		function getTriggerArea() {
			if (triggerArea.invalid) {
				var clientRect = ctrl.elt.getClientRects();
				if (clientRect && clientRect.length) {
					var rect = clientRect[0];
					if (rect) {
						// zone de la scrollbar
						var bgSize = ctrl.ngelt.css('background-size');
						if (ctrl.horizontal) {
							var m = bgSize.match(/\D*\d+\D*(\d+)\D*/);
							var s = m.length > 0 ? parseInt(m[1]) : 4;
							triggerArea = {
								left: rect.left, right: rect.right,
								width: rect.width, height: s,
								top: rect.bottom - s, bottom: rect.bottom
							};
						} else {
							var m = bgSize.match(/\D*(\d+)\D*\d+\D*/);
							var s = m.length > 0 ? parseInt(m[1]) : 4;
							triggerArea = {
								left: rect.right - s, right: rect.right,
								width: s, height: rect.height,
								top: rect.top, bottom: rect.bottom
							};
						}
					}
				}
			}
			return triggerArea;
		}
		/**
		 * Retourne la zone correspondante à la scrollbar
		 * @return {Rectangle}
		 */
		var sbArea = getNullArea();
		function getScrollbarArea() {
			if (sbArea.invalid) {
				sbArea = getArea(ctrl.sb, true);
			}
			return sbArea;
		}
		/**
		 * Retourne la zone correspondante à la directive
		 * @return {Rectangle}
		 */
		var eltArea = getNullArea();
		function getEltArea() {
			if (eltArea.invalid) {
				eltArea = getArea(ctrl.elt, true);
			}
			return eltArea;
		}
		/**
		 * Retourne la zone correspondante à l'element html en argument
		 * @param {HTMLElement} elt
		 * @param {boolean} validation
		 * @return {Rectangle}
		 */
		function getArea(elt, validation) {
			var clientRect = elt.getClientRects();
			if (clientRect && clientRect.length) {
				var rect = clientRect[0];
				if (rect) {
					rect.invalid = validation && !isElementInViewport(rect);
					return rect;
				}
			}
			return getNullArea();
		}
		function isElementInViewport(rect) {
			if (ctrl.horizontal) {
				return rect.left >= 0 && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
			} else {
				return rect.top >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight);
			}
		}
		/**
		 * Retourne un rectangle de valeurs 0
		 * @return {Rectangle}
		 */
		function getNullArea() {
			return {left: 0, right: 0, width: 0, height: 0, top: 0, bottom: 0, invalid: true};
		}
	}
27478
function Konnekt(node,params,predt,postdt,cb)
    {
      /* name of the component */
      var __name = node.tagName.toLowerCase(),
          
          /* the mapped binds */
          __mappedAttrs,
          
          /* we can get a list of all possibe events from the HTMLElement prototype */
          __events = Object.keys(HTMLElement.prototype)
          .filter(function(prop){
            /* we filter for 'on' properties as these are all events */
            return (prop.indexOf('on') === 0);
          }),
          
          /* Pre -- all about built in data this will be allocated later to seperate file */ /* Note** we may need to take another look at this as mixed pointers are being double processed */
          pre = passKeys(_config,{}),
          
          /* post all about post set data and pointers */ /* Note** we may need to take another look at this as mixed pointers are being double processed */
          post = {};
      
      /* params are extra information passed to the viewmodel constructor, example: componentNode */
      if(params === undefined) params = [];
      
      if(predt) passKeys(predt,pre);
      
      Object.defineProperty(pre,'local',setDescriptor(pre.local || ("local_"+__name+"-"+(Math.floor(Math.random() * Date.now()) + 1)),true,false,true));
      Object.defineProperty(pre,'id',setDescriptor(pre.id || ("id_"+__name+"-"+(Math.floor(Math.random() * Date.now()) + 1)),true,false,true));
      
      /* base core filters usable in all components */
      Object.defineProperty(pre,'filters',setDescriptor(pre.filters || {},false,false,true));
      
      
      if(typeof pre.onFinish !== 'function') pre.onFinish = function(){};
      Object.defineProperty(pre,'onGlobalFinish',setDescriptor(pre.onFinish,true,false,true));
      
      /* add listen method */
      pre.listen = listen;
      Object.defineProperty(pre,'listen',setDescriptor(pre.listen,true,false,true));
      
      /* add unlisten method */
      pre.unlisten = unlisten;
      Object.defineProperty(pre,'unlisten',setDescriptor(pre.unlisten,true,false,true));
      
      /* add alert method */
      pre.alert = alert;
      Object.defineProperty(pre,'alert',setDescriptor(pre.alert,true,false,true));

      /* whether to attempt to store data in sessionStorage */
      Object.defineProperty(pre,'sessionStorage',setDescriptor((false),true,false,true));

      /* whether to attempt to store data in localStorage */
      Object.defineProperty(pre,'localStorage',setDescriptor((false),true,false,true));

      /* whether to attempt to store data in the model */
      Object.defineProperty(pre,'store',setDescriptor((false),true,false,true));

      /* if this component can have children components of the same type, to prevent recursion */
      Object.defineProperty(pre,'multiple',setDescriptor((false),true,false,true));
      
      if(postdt) passKeys(postdt,post);
      
      /* if the component contained any innerHTML this gets placed into a post bindable */
      post.innerHTML = Array.prototype.slice.call(node.childNodes);
      
      for(var x=0,len=node.attributes.length;x<len;x++)
      {
        post[node.attributes[x].name] = node.attributes[x].value;
      }
      
      /* add all events to post for binding to inner component */
      for(var x=0,len=__events.length;x<len;x++)
      {
        if(node[__events[x]]) post[__events[x]] = node[__events[x]];
      }
      
      /* add any data attached to k_post  property */
      if(node.k_post) passKeys(node.k_post,post);
      
      /* The main viewmodel constructor */
      function createViewmodel(name,component,params,pre,post)
      {
        /* creates blank observable data set */
        var obsv = _mixed({},name);

        /* Attach Pre properties, or pre designed attachments for every Data set */
        for(var x=0,keys=Object.keys(pre),len=keys.length;x<len;x++)
        {
          if(_ignoreList.indexOf(keys[x]) !== -1)
          {
            Object.defineProperty(obsv,keys[x],setDescriptor(pre[keys[x]],(keys[x] !== 'filters')));
          }
          else
          {
            if(pre.pointers)
            {
              if(pre.pointers[keys[x]] === undefined) obsv.set(keys[x],pre[keys[x]]);
            }
            else
            {
              obsv.set(keys[x],pre[keys[x]]);
            }
          }
        }
        
        if(pre.pointers)
        {
          if(!obsv.pointers) Object.defineProperty(obsv,'pointers',setDescriptor({},false,true));
          for(var x=0,keys=Object.keys(pre.pointers),len=keys.length;x<len;x++)
          {
            obsv.pointers[keys[x]] = pre.pointers[keys[x]];
            obsv.addPointer(obsv.pointers[keys[x]].point,obsv.pointers[keys[x]].key,keys[x]);
          }
        }
        
        /* if there are any prototypes on this component they are added to the Data sets prototype */
        for(var x=0,keys=Object.keys(component.prototype),len=keys.length;x<len;x++)
        {
          Object.defineProperty(obsv,[keys[x]],setDescriptor(component.prototype[keys[x]],true));
        }
        
        /* we then apply the component constructor to the data set in order to add the 'this' properties from it and pass in the params */
        component.apply(obsv,params);
        
        /* Post attachments, overwritables, for data or pointers */
        for(var x=0,keys=Object.keys(post),len=keys.length;x<len;x++)
        {
          if(_ignoreList.indexOf(keys[x]) !== -1)
          {
            Object.defineProperty(obsv,keys[x],setDescriptor(post[keys[x]],(keys[x] !== 'filters')));
          }
          else
          {
            if(post.pointers)
            {
              if(post.pointers[keys[x]] === undefined) obsv.set(keys[x],post[keys[x]]);
            }
            else
            {
              obsv.set(keys[x],post[keys[x]]);
            }
          }
        }
        
        /* post pointers */
        if(post.pointers)
        {
          if(!obsv.pointers) Object.defineProperty(obsv,'pointers',setDescriptor({},false,true));
          for(var x=0,keys=Object.keys(post.pointers),len=keys.length;x<len;x++)
          {
            obsv.pointers[keys[x]] = post.pointers[keys[x]];
            obsv.addPointer(obsv.pointers[keys[x]].point,obsv.pointers[keys[x]].key,keys[x]);
          }
        }
        
        /* map filters as binded to vm */
        for(var x=0,keys=Object.keys(obsv.filters),len=keys.length;x<len;x++)
        {
          obsv.filters[keys[x]] = obsv.filters[keys[x]].bind(obsv);
        }

        /* Apply session storage if set, this allows for storing this vm in session storage, only those values that are enumerable */
        if(obsv.sessionStorage)
        {
            var storage = sessionStorage.getItem((obsv.id || name));
            
            /* load storage into the data set if it is set */
            if(storage)
            {
                storage = JSON.parse(storage);
                for(var x=0,keys=Object.keys(storage),len=keys.length;x<len;x++)
                {
                    obsv.set(keys[x],storage[keys[x]]);
                }
            }
          
            /* set the storage object with the defaults */
            else
            {
                sessionStorage.setItem((obsv.id || name),obsv.stringify());
            }
          
            /* if any data updates then the storage will be updated along with it */
            obsv.addChildDataUpdateListener('*',function(){
                sessionStorage.setItem((obsv.id || name),obsv.stringify());
            });
        }

        /* Apply local storage if set, similiar to session Storage except this persists even after browser is closed */
        if(obsv.localStorage)
        {
            var storage = localStorage.getItem((obsv.id || name));
          
            /* load storage into the data set if it is set */
            if(storage)
            {
                storage = JSON.parse(storage);
                for(var x=0,keys=Object.keys(storage),len=keys.length;x<len;x++)
                {
                    obsv.set(keys[x],storage[keys[x]]);
                }
            }
          
            /* set the storage object with the defaults */
            else
            {
                localStorage.setItem((obsv.id || name),obsv.stringify());
            }
          
            /* if any data updates then the storage will be updated along with it */
            obsv.addChildDataUpdateListener('*',function(){
                localStorage.setItem((obsv.id || name),obsv.stringify());
            });
        }
        
        if(obsv.store)
        {
            /* adds a pointer in model to this viewmodel, look into using id as an id from component: <test id="storeid"></test> */
            _model.set((obsv.id || name),obsv);
        }

        return obsv;
      }
      
      function getInnerMapper(name)
      {
        return new RegExp('('+_mapper.start()+'>'+name+'(.*?)'+_mapper.end()+')','g');
      }
      
      function innerMapperKeys()
      {
        return new RegExp('('+_mapper.start()+'>(.*?)'+_mapper.end()+')','g');
      }
      
      /* in charge of connecting the viewmodel up to the allocated maps */
      function mapTargets(target,mappedAttrs,vm)
      {
        /* attaches viewmodel to wrapper */
        target.kb_viewmodel = vm;
        
        /* map nodes with their bindings */
        var maps = mappedAttrs.maps = mappedAttrs.map(mappedAttrs.wrapper);

        mappedAttrs.wrapper.kb_maps = maps;
        
        /* loops through maps: {key:[map,map],key2:[map,map]} */
        Object.keys(maps).forEach(function(key){
          maps[key].forEach(function(map){
            switch(map.type)
            {
              case 'for':
                /* connects viewmodel and then loop creates components for converting and deletes original map*/
                map.connect(vm).createloop();
              break;
              case 'component':
                /* connects viewmodel updates value and then deletes map as it won't be used again */
                map.connect(vm).unsync();
              break;
              case 'node':
                map.connect(vm).replaceNode();
              break;
              default:
                /* standard data connection and value set */
                map.connect(vm);
              break;
            }
          })
        });
        
        mappedAttrs.wrapper.kb_viewmodel.onFinish.call(mappedAttrs.wrapper.kb_viewmodel,mappedAttrs.wrapper);
        if(mappedAttrs.wrapper.kb_viewmodel.onGlobalFinish)
        {
          mappedAttrs.wrapper.kb_viewmodel.onGlobalFinish.call(mappedAttrs.wrapper.kb_viewmodel,mappedAttrs.wrapper);
        }
        if(mappedAttrs.wrapper.kb_viewmodel.onNodeFinish)
        {
          mappedAttrs.wrapper.kb_viewmodel.onNodeFinish.call(mappedAttrs.wrapper.kb_viewmodel,mappedAttrs.wrapper);
        }
      }

      function getInnerComponents(node)
      {
        var nodes = node.querySelectorAll('*');
        for(var x=0,len=nodes.length;x<len;x++)
        {
          if(nodes[x] instanceof HTMLUnknownElement)
          {
            Konnekt(nodes[x]);
          }
        }
      }

      function init(name,node)
      {
        /* Create node template and map the inner nodes of the template */
        __mappedAttrs = new _mapper(node,true);
        
        /* do a replace for simple initial replacements inside binds */
        __mappedAttrs.wrapper.innerHTML = __mappedAttrs.template;
        
        __mappedAttrs.wrapper.kb_mapper = __mappedAttrs.wrapper;
        
        /* define component tree for multiples later */
        Object.defineProperty(__mappedAttrs.wrapper,'__kbcomponenttree',setDescriptor(node.kb_mapper ? node.kb_mapper.__kbcomponenttree.slice() : []));
        
        /* replace original node with new templated node */
        node.parentElement.stopChange().replaceChild(__mappedAttrs.fragment,node);
        
        /* add new nodes to params for passing to viewmodels */
        params.unshift(__mappedAttrs.wrapper);
        
        /* map targets connects the viewmodel data to the dom and vice versa */
        mapTargets(__mappedAttrs.wrapper,__mappedAttrs,createViewmodel(name,_viewmodels[name],params,pre,post));
        
        /* check for multiples */
        if(__mappedAttrs.wrapper.__kbcomponenttree.indexOf(name) === -1 || __mappedAttrs.wrapper.kb_viewmodel.multiple)
        {
          /* add to component tree and search for inner unkown components */
          __mappedAttrs.wrapper.__kbcomponenttree.push(name);
          __mappedAttrs.wrapper.className += (" "+__mappedAttrs.wrapper.kb_viewmodel.local);
          __mappedAttrs.wrapper.className += (" "+__mappedAttrs.wrapper.kb_viewmodel.id);
          __mappedAttrs.wrapper.className += (!!__mappedAttrs.wrapper.kb_viewmodel.loopid ? " "+__mappedAttrs.wrapper.kb_viewmodel.loopid : "");
          
          /* watch for changes to alert any scope messages */
          __mappedAttrs.wrapper.kb_viewmodel.subscribeDeep('*',scopesubscription).callAllSubscribers();
          __mappedAttrs.wrapper.kb_viewmodel.kbnode = __mappedAttrs.wrapper;
          
          /* stop any html updates */
          __mappedAttrs.wrapper.addChildAttrListener('html',function(e){
            if(!e.stopChange)
            {
              /* check if its a new component being appended or check if its a single bind */
              if(['appendChild','insertSibling','insertBefore','insertAfter'].indexOf(e.attr) !== -1 && (e.arguments[0] instanceof HTMLUnknownElement || e.arguments[0] instanceof HTMLScriptElement))
              {
                return true;
              }
              else if(['innerHTML','textContent'].indexOf(e.attr) !== -1 && (e.child ? !!e.child.__kbhtmllistener : !!e.target.__kbhtmllistener))
              {
                return true;
              }
              e.preventDefault();
              e.stopPropagation();
            }
          });
          __mappedAttrs.wrapper.addChildAttrUpdateListener('html',function(e){
            if(['appendChild','insertSibling','insertBefore','insertAfter'].indexOf(e.attr) !== -1 && e.arguments[0] instanceof HTMLUnknownElement)
            {
              Konnekt(e.arguments[0]);
            }
          });
          
          getInnerComponents(__mappedAttrs.wrapper);
        }
        else
        {
          console.error("Warning!! You are attempting to make a recursive component %o, recursive components can lead to memory stack overflows unless properly handled, Please check your components html for use of this component, if You want this to be a recursive component please set `this.multiple = true;`",name);
          console.error("Recursive Component %o on %o",__mappedAttrs.wrapper,__mappedAttrs.wrapper.parentElement);
        }
      }

      if(!Konnekt.isRegistered(__name) && !node.kb_isLoading)
      {
        Konnekt.loadWaitList(__name,function(n,c){
          init(__name,node);
        });
        if(!Konnekt.loadWaitList(__name).loading) 
        {
          Konnekt.loadWaitList(__name).loading = true;
          _Loader(__name);
        }
      }
      else
      {
        if(Konnekt.isRegistered(__name)) init(__name,node);
      }
    }
60296
public function postAction()
    {
        $postId = $this->getEvent()->getRouteMatch()->getParam('post');
        $voted = false;
        $statusMail = false;
        $mailService = $this->getServiceLocator()->get('playgroundgame_message');
        $to = '';
        $skinUrl = $this->getGameService()->getServiceManager()->get('ViewRenderer')->url(
            'frontend',
            array(),
            array('force_canonical' => true)
        );
        $config = $this->getGameService()->getServiceManager()->get('config');
        if (isset($config['moderation']['email'])) {
            $to = $config['moderation']['email'];
        }

        if (! $postId) {
            return $this->notFoundAction();
        }

        // Je recherche le post associé à entry + status == 0. Si non trouvé, je redirige vers home du jeu.
        $post = $this->getGameService()->getPostVotePostMapper()->findById($postId);

        if (! $post || $post->getStatus() === 9) {
            return $this->redirect()->toUrl(
                $this->frontendUrl()->fromRoute(
                    'postvote',
                    array('id' => $this->game->getIdentifier())
                )
            );
        }

        $formModeration = new Form();
        $formModeration->setAttribute('method', 'post');

        $formModeration->add(array(
            'name' => 'moderation',
            'attributes' => array(
                'type' => 'hidden',
                'value' => '1'
            ),
        ));

        $form = new \PlaygroundGame\Form\Frontend\PostVoteVote(
            $this->frontendUrl()->fromRoute(
                'postvote/post/captcha',
                array(
                    'id' => $this->game->getIdentifier(),
                    'post' => $postId,
                )
            )
        );

        if ($this->user) {
            $form->remove('captcha');
            if (count($this->getGameService()->getPostvoteVoteMapper()->findBy(array('user' => $this->user, 'post' =>$post))) > 0) {
                $voted = true;
            }
        }

        $alreadyVoted = '';
        $reportId = '';

        $request = $this->getRequest();
        if ($request->isPost()) {
            $data = $request->getPost()->toArray();
            if (isset($data['moderation'])) {
                $formModeration->setData($data);
                if ($formModeration->isValid()) {
                    $from = $to;
                    $subject= 'Moderation Post and Vote';
                    $result = $mailService->createHtmlMessage(
                        $from,
                        $to,
                        $subject,
                        'playground-game/email/moderation',
                        array('data' => $data, 'skinUrl' => $skinUrl)
                    );
                    $mailService->send($result);
                    if ($result) {
                        $statusMail = true;
                        $reportId = $data['reportid'];
                    }
                }
            } else {
                $form->setData($request->getPost());
                if ($form->isValid()) {
                    if ($this->getGameService()->addVote(
                        $this->user,
                        $this->getRequest()->getServer('REMOTE_ADDR'),
                        $post
                    )) {
                        $voted = true;
                    } else {
                        $alreadyVoted = 'Vous avez déjà voté!';
                    }
                }
            }
        }

        $viewModel = $this->buildView($this->game);
        $viewModel->setVariables(
            array(
                'post'  => $post,
                'voted' => $voted,
                'form'  => $form,
                'formModeration' => $formModeration,
                'statusMail' => $statusMail,
                'alreadyVoted' => $alreadyVoted,
                'reportId' => $reportId,
            )
        );

        return $viewModel;
    }