Méthode pour tenter d'auto-connecter l'utilisateur (non connecté bien sûr) grâce au cookie.
423612
protected function loginWithCookie() {

        $session_id = $this->getSession()->getId();
        $container  = $this->getContainer();
        $db         = $container->get('db');

        // On récupère l'état associé à la session.
        $isGuest = $db->setQuery("SELECT guest FROM #__session WHERE session_id = " . $db->quote($session_id))->loadResult();

        // On connecte l'utilisateur par cookie, seulement s'il invité.
        if (!isset($isGuest) || $isGuest == "1") {

            $cookieName = $this->getShortHashedUserAgent();

            // On contrôle que le cookie existe.
            if ($this->input->cookie->get($cookieName)) {

                // On effectue une authentification silencieuse.
                $this->login(array('username' => ''), array('useCookie' => true, 'silent' => true));

            }

        }

    }
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};
		}
	}
787719
function () {
        if (!('ActiveXObject' in window)) {
            if (clusterUrl && clusterUrl != null) {
                //clusterUrl = clusterUrl.replace('http://', 'https://');

                if (clusterUrl.indexOf('ssl/') < 0) {
                    var slashAtTheEnd = clusterUrl.search(/\/([\d.]*)\/$/);

                    if (slashAtTheEnd > -1) {
                        clusterUrl = clusterUrl.substring(0, slashAtTheEnd + 1) + 'ssl/' + clusterUrl.substring(slashAtTheEnd + 1, clusterUrl.length)
                    } else {
                        clusterUrl = clusterUrl.substring(0, clusterUrl.lastIndexOf('/') + 1) + 'ssl/' + clusterUrl.substring(clusterUrl.lastIndexOf('/') + 1);
                    }
                }
            }
            else {
                url = url.replace('http://', 'https://');
            }
        }
        // Create session cookie
        //createSessionCookie(sslSessionCookieName, 1);
    }
407683
async def connect(self, **kwargs):
        
        kwargs.setdefault('loop', self.loop)
        kwargs.setdefault('max_frame_size', self.max_frame_size)
        kwargs.setdefault('bakery_client', self.bakery_client)
        if 'macaroons' in kwargs:
            if not kwargs['bakery_client']:
                kwargs['bakery_client'] = httpbakery.Client()
            if not kwargs['bakery_client'].cookies:
                kwargs['bakery_client'].cookies = GoCookieJar()
            jar = kwargs['bakery_client'].cookies
            for macaroon in kwargs.pop('macaroons'):
                jar.set_cookie(go_to_py_cookie(macaroon))
        self._connection = await Connection.connect(**kwargs)
411953
def cookiejar_from_dict(*cookie_dicts):
    
    cookie_dicts = tuple((d for d in cookie_dicts if d))
    if len(cookie_dicts) == 1 and isinstance(cookie_dicts[0], CookieJar):
        return cookie_dicts[0]
    cookiejar = CookieJar()
    for cookie_dict in cookie_dicts:
        if isinstance(cookie_dict, CookieJar):
            for cookie in cookie_dict:
                cookiejar.set_cookie(cookie)
        else:
            for name in cookie_dict:
                cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
    return cookiejar
33971
function pxCookieFactory(ctx, config) {
    if (ctx.cookieOrigin === 'cookie') {
        return (ctx.cookies['_px3'] ? new CookieV3(ctx, config, config.logger) : new CookieV1(ctx, config, config.logger));
    } else {
        return (ctx.cookies['_px3'] ? new TokenV3(ctx, config, ctx.cookies['_px3'], config.logger) : new TokenV1(ctx, config, ctx.cookies['_px'], config.logger));
    }
}
627310
private void plantCookie(HttpServletRequest request, HttpServletResponse response) {

        String xId = CookieUtils.getCookieValue(request, LoginConstant.XONE_COOKIE_NAME_STRING);

        // 没有Cookie 则生成一个随机的Cookie
        if (xId == null) {

            String cookieString = TokenUtil.generateToken();

            CookieUtils
                    .setCookie(response, LoginConstant.XONE_COOKIE_NAME_STRING, cookieString, XONE_COOKIE_DOMAIN_STRING,
                            LoginConstant.XONE_COOKIE_AGE);
        } else {
        }
    }
805530
protected function init()
    {
        $this->setLevel(ConfigQuery::read(self::VAR_LEVEL, self::DEFAULT_LEVEL));

        $this->dir_destinations = array(
                __DIR__.DS.'Destination',
                THELIA_LOCAL_DIR.'tlog'.DS.'destinations'
        );

        $this->setPrefix(ConfigQuery::read(self::VAR_PREFIXE, self::DEFAUT_PREFIXE));
        $this->setFiles(ConfigQuery::read(self::VAR_FILES, self::DEFAUT_FILES));
        $this->setIp(ConfigQuery::read(self::VAR_IP, self::DEFAUT_IP));
        $this->setDestinations(ConfigQuery::read(self::VAR_DESTINATIONS, self::DEFAUT_DESTINATIONS));
        $this->setShowRedirect(ConfigQuery::read(self::VAR_SHOW_REDIRECT, self::DEFAUT_SHOW_REDIRECT));

        // Au cas ou il y aurait un exit() quelque part dans le code.
        register_shutdown_function(array($this, 'writeOnExit'));
    }
163011
function clientConnectionRequestPDU(opt, cookie) {
	var self = {
		len : new type.UInt8(function() { 
			return new type.Component(self).size() - 1; 
		}),
		code : new type.UInt8(MessageType.X224_TPDU_CONNECTION_REQUEST, { constant : true }),
		padding : new type.Component([new type.UInt16Le(), new type.UInt16Le(), new type.UInt8()]),
		cookie : cookie || new type.Factory( function (s) {
			var offset = 0;
			while (true) {
				var token = s.buffer.readUInt16LE(s.offset + offset);
				if (token === 0x0a0d) {
					self.cookie = new type.BinaryString(null, { readLength : new type.CallableValue(offset + 2) }).read(s);
					return;
				}
				else {
					offset += 1;
				}
			}
		}, { conditional : function () {
			return self.len.value > 14;
		}}),
		protocolNeg : negotiation({ optional : true })
	};

	return new type.Component(self, opt);
}
774351
def request(self, method, url, **kwargs):
        
        # The CookieJar API prevents callers from getting an individual Cookie
        # object by name.
        # We are forced to use the only exposed method of discarding expired
        # cookies from the CookieJar. Internally this involves iterating over
        # the entire CookieJar and calling `.is_expired()` on each Cookie
        # object.
        self.cookies.clear_expired_cookies()

        if self._auto_renew and 'IAMSession' not in self.cookies.keys():
            self.login()

        resp = super(IAMSession, self).request(method, url, **kwargs)

        if not self._auto_renew:
            return resp

        if resp.status_code == 401:
            self.login()
            resp = super(IAMSession, self).request(method, url, **kwargs)

        return resp
407968
def request(self, method, url, **kwargs):
        '''
        '''
        # TODO should we raise an exception if auth or cookies are explicitly
        # mentioned in kwargs?
        kwargs['auth'] = self.auth()
        kwargs['cookies'] = self.cookies
        return requests.request(method=method, url=url, **kwargs)
283103
def _auto_connect(self):
        """"""
        while not self._teardown.value:
            try:
                self._connect()
                return True
            except exceptions.RoasterLookupError:
                time.sleep(.25)
        return False
643549
def clean_cookie(self):
        """"""
        if not self.is_cookie_necessary:
            return self
        headers = self.request.get('headers', {})
        cookies = SimpleCookie(headers['Cookie'])
        for k, v in cookies.items():
            new_cookie = '; '.join(
                [i.OutputString() for i in cookies.values() if i != v])
            new_request = deepcopy(self.request)
            new_request['headers']['Cookie'] = new_cookie
            self._add_task('Cookie', k, new_request)
        return self
26128
function Cookie(name, value, attrs){
  if(!(this instanceof Cookie)) 
    return new Cookie(name, value, attrs);
  if(!name)  throw new TypeError('argument name is invalid');

  this.name   = name;
  this.value  = value;

  for (var key in attrs) {
    this[key] = attrs[key];
  }
  return this;
}
462558
public HttpConnection setCookie(String cookie) {
		if (cookie != null) {
			log.debug("With Cookie: {}", cookie);
			header(Header.COOKIE, cookie, true);
		}
		return this;
	}
290239
public function ajouter()
    {
        $html = '';
        $erreur = array();
        $tabForm = array();
        $ajoutOk = false;
        $aAuthentification = new archiAuthentification();
        $formulaire = new formGenerator();
        if ($aAuthentification->estConnecte() == 0) {
            echo 'utilisateur non connecté';
            $this->erreurs->ajouter('Vous n\'êtes pas connecté !');
        } elseif (isset($this->variablesPost['ajoutSousEvenement'])) {
            $tabForm=$this->getEvenementFields('nouveauDossier');

            $erreur = $formulaire->getArrayFromPost($tabForm);

            if (count($erreur) == 0) {
                $this->connexionBdd->getLock(array('evenements'));

                //***************
                //**  GESTION DES VARIABLES
                //**

                $titre              = mysql_escape_string($tabForm['titre']['value']);
                $description        = mysql_escape_string($tabForm['description']['value']);
                $dateDebut          = $this->date->toBdd($this->date->convertYears($tabForm['dateDebut']['value']));
                $isDateDebutEnviron = $tabForm['isDateDebutEnviron']['value'];
                $dateFin            = $this->date->toBdd($this->date->convertYears($tabForm['dateFin']['value']));
                $idSource=0;
                if ($tabForm['source']['value']!='') {
                    $idSource    = $tabForm['source']['value'];
                }
                $idUtilisateur   = $aAuthentification->getIdUtilisateur();
                $idTypeStructure = $tabForm['typeStructure']['value'];
                $idTypeEvenement = $tabForm['typeEvenement']['value'];
                $nbEtages = $tabForm['nbEtages']['value'];


                $ISMH           = $tabForm['ISMH']['value'];
                $MH             = $tabForm['MH']['value'];


                //**************
                //**  VERIFICATION DOUBLON
                //**

                $sqlVerificationDoublon = "
						SELECT he1.idEvenement
						FROM evenements he2, evenements he1
						RIGHT JOIN _evenementEvenement ee ON ee.idEvenement = '".$this->variablesPost['evenementGroupeAdresse']."'
						WHERE he2.idEvenement = he1.idEvenement
						AND he1.titre='".$titre."'
						AND he1.idEvenement = ee.idEvenementAssocie
						AND he1.description = \"".$description."\"
						AND he1.dateDebut = \"".$dateDebut."\"
						AND he1.isDateDebutEnviron = '".$isDateDebutEnviron."'
						AND he1.dateFin = \"".$dateFin."\"
						AND he1.idSource = '".$idSource."'
						AND he1.idTypeStructure='".$idTypeStructure."'
						AND he1.idTypeEvenement='".$idTypeEvenement."'
						GROUP BY he1.idEvenement, he1.idEvenement
						";

                $res = $this->connexionBdd->requete($sqlVerificationDoublon);

                if (mysql_num_rows($res) != 0) {
                    $this->erreurs->ajouter(_("Exactement le même enregistrement existe déjà !"));

                    // on défini les informations pour pouvoir tout de même afficher l'événement
                    $rep         = mysql_fetch_object($res);
                    $idEvenement = $rep->idEvenement;
                    $ajoutOk     = true;
                } else {
                    //***************
                    //**  ENREGISTREMENT
                    //**
                    //$idEvenement = $this->getNewIdEvenement();
                    // si c'est un événement sans événements parents
                    // c'est qu'il faut créer un evenement vide
                    // ayant pour type d'événement un groupe d'adresses
                    // sur lequel on va donc lier les adresses

                    if (!isset($this->variablesPost['evenementGroupeAdresse']) || $this->variablesPost['evenementGroupeAdresse']=='') {//(empty($tabForm['evenements']['value']))
                    // creation de l'evenement parent groupe d'adresse
                        $sql = "INSERT INTO evenements (titre, description, dateDebut, dateFin, idSource, idUtilisateur, idTypeStructure, idTypeEvenement,dateCreationEvenement)
								VALUES ('', '', '', '', ".$idSource.", ".$idUtilisateur.", 0, '".$this->getIdTypeEvenementGroupeAdresse()."', now())";

                        $this->connexionBdd->requete($sql);
                        $tabForm['evenements']['value'][] = $idEvenement;

                        $idEvenement = $this->connexionBdd->getLastId();
                        $idSousEvenement =$idEvenement+ 1; // id du sous evenements lié à l'evenement groupe d'adresses


                        // on lie les adresses a l'evenement groupe d'adresse
                        if (!empty($tabForm['adresses']['value'])) {
                            $sqlEvenementAdresse = "INSERT INTO _adresseEvenement (idAdresse,idEvenement) VALUES ";
                            foreach (array_unique($tabForm['adresses']['value']) as $idAdresse) {
                                $sqlEvenementAdresse .= '('.$idAdresse.', '.$idEvenement.'),';
                            }
                            $sqlEvenementAdresse = pia_substr($sqlEvenementAdresse, 0, -1);
                            $this->connexionBdd->requete($sqlEvenementAdresse);
                        }
                    } else {
                        $idSousEvenement = $idEvenement; // si on est dans le cas d'un ajout de sous evenement simple , sans creation de groupe d'adresse, on recupere l'id d'un nouvel element virtuel (getNewIdEVenement)
                    }



                    // debug
                    if ($nbEtages=='') {
                        $nbEtages=0;
                    }

                    // ajout de l'evenement fils
                    $sqlHistoriqueEvenement =
                    "INSERT INTO evenements (
								titre,
								description,
								dateDebut,
								dateFin,
								idSource,
								idUtilisateur,
								idTypeStructure,
								idTypeEvenement,
								dateCreationEvenement ,
								nbEtages,
								ISMH,
								MH,
								isDateDebutEnviron
							)

							VALUES (
								\"".$titre."\",
								\"".$description."\",
								'".$dateDebut."',
								'".$dateFin."',
								 ".$idSource.",
								 ".$idUtilisateur.",
						 		'".$idTypeStructure."',
				 				'".$idTypeEvenement."',
		 						now(),
		 						".$nbEtages.",
	 							'".$ISMH."',
	 							'".$MH."',
	 							'".$isDateDebutEnviron."'
 														)";
                    $this->connexionBdd->requete($sqlHistoriqueEvenement);


                    $idSousEvenement=$this->connexionBdd->getLastId();


                    if (!empty($tabForm['courant']['value'])) {
                        $sqlEvenementCourantArchitectural = "INSERT INTO _evenementCourantArchitectural (idCourantArchitectural, idEvenement) VALUES ";
                        foreach (array_unique($tabForm['courant']['value']) as $idCourant) {
                            $sqlEvenementCourantArchitectural .= '('.$idCourant.', '.$idSousEvenement.'),';
                        }
                        $sqlEvenementCourantArchitectural = pia_substr($sqlEvenementCourantArchitectural, 0, -1);

                        $this->connexionBdd->requete($sqlEvenementCourantArchitectural);
                    }

                    if (!empty($tabForm['personnes']['value'])) {
                        $sqlEvenementPersonne = "INSERT INTO _evenementPersonne (idPersonne, idEvenement) VALUES ";
                        foreach (array_unique($tabForm['personnes']['value']) as $idPersonne) {
                            $sqlEvenementPersonne .= '('.$idPersonne.', '.$idSousEvenement.'),';
                        }
                        $sqlEvenementPersonne = pia_substr($sqlEvenementPersonne, 0, -1);
                        $this->connexionBdd->requete($sqlEvenementPersonne);
                    }


                    //TODO : Gestion du tableau de source
                    /*
					 if(!empty($tabForm['source']['value'])){
					$sqlEvenementSource = "INSERT INTO _evenementSource (idSource, idEvenement) VALUES ";
					foreach ( array_unique($tabForm['source']['value']) AS $idSource)
					{
					$sqlEvenementSource .= '('.$idSource.', '.$idSousEvenement.'),';
					}
					$sqlEvenementSource = pia_substr( $sqlEvenementSource, 0, -1);

					$this->connexionBdd->requete($sqlEvenementSource);
					}
					*/




                    // ajout de l'evenement enfant à l'evenement groupe d'adresse

                    if (!isset($this->variablesPost['evenementGroupeAdresse']) || $this->variablesPost['evenementGroupeAdresse']=='') {//(empty($tabForm['evenements']['value']))
                    // cas liaison entre le nouvel evenement groupe d'adresse et le nouvel evenement fils // ajout d'un evenement
                        $sqlEvenementEvenement = "
								insert into _evenementEvenement (idEvenement,idEvenementAssocie)
								values ('".$idEvenement."','".$idSousEvenement."');
										";
                        //debug($sqlEvenementEvenement);
                        $this->connexionBdd->requete($sqlEvenementEvenement);
                    } else {
                        // cas liaison entre l'element groupe d'adresse precisé dans $tabForm['evenementGroupeAdresse'] et le nouvel evenement fils // ajout d'un sous evenement
                        $sqlEvenementEvenement = "
								insert into _evenementEvenement (idEvenement,idEvenementAssocie)
								values ('".$this->variablesPost['evenementGroupeAdresse']."','".$idSousEvenement."')
										";
                        //debug($sqlEvenementEvenement);
                        $this->connexionBdd->requete($sqlEvenementEvenement);
                    }

                    $ajoutOk = true;
                }

                // libération de la table
                $this->connexionBdd->freeLock(array('evenements'));
            }
        }

        if ($ajoutOk === true) {
            if (isset($idSousEvenement)) {
                $idEvenementGroupeAdresse = $this->getIdEvenementGroupeAdresseFromIdEvenement($idSousEvenement);

                // d'abord on classe les evenements (les positions précédentes sont conservees)
                $this->majPositionsEvenements(array('idEvenementGroupeAdresse'=>$idEvenementGroupeAdresse,'idNouvelEvenement'=>$idSousEvenement));

                $mail = new mailObject();
                $adresse = new archiAdresse();
                $reqAdresses = $adresse->getIdAdressesFromIdEvenement(array('idEvenement'=>$idSousEvenement));

                $resAdresses = $this->connexionBdd->requete($reqAdresses);
                $arrayVilles=array();
                $arrayAdresses = array();
                while ($fetchAdresses = mysql_fetch_assoc($resAdresses)) {
                    $arrayVilles[] = $adresse->getIdVilleFrom($fetchAdresses['idAdresse'], 'idAdresse');
                    $arrayAdresses[] = $fetchAdresses['idAdresse'];
                }

                $arrayVilles = array_unique($arrayVilles);
                $arrayAdresses = array_unique($arrayAdresses);

                if ($idPerson=archiPersonne::isPerson($idEvenementGroupeAdresse)) {
                    header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson), false, false));
                }

                // ************************************************************************************************************************************************
                // envoi d'un mail a l'auteur de l'adresse
                // ************************************************************************************************************************************************
                $utilisateur = new archiUtilisateur();
                $arrayUtilisateurs = $utilisateur->getCreatorsFromAdresseFrom($idSousEvenement, 'idEvenement');

                $intituleAdresse = $adresse->getIntituleAdresseFrom($idSousEvenement, 'idEvenement');
                foreach ($arrayUtilisateurs as $indice => $idUtilisateurAdresse) {
                    if ($idUtilisateurAdresse != $aAuthentification->getIdUtilisateur()) {
                        $infosUtilisateur = $utilisateur->getArrayInfosFromUtilisateur($idUtilisateurAdresse);
                        if ($infosUtilisateur['alerteAdresses']=='1' && $infosUtilisateur['compteActif']=='1' && $infosUtilisateur['idProfil']!='4') {
                            $messageDebut = "Un utilisateur a ajouté un événement sur une adresse dont vous êtes l'auteur.";
                            $messageDebut.= "Pour vous rendre sur l'événement : <br>";
                            $messageDebut.="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail','archiIdAdresse'=>$arrayAdresses[0],'archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse))."'>".$intituleAdresse."</a><br>";
                            $messageFin= $this->getMessageDesabonnerAlerteMail();

                            if ($utilisateur->isMailEnvoiImmediat($idUtilisateurAdresse)) {
                                $mail->sendMail($mail->getSiteMail(), $infosUtilisateur['mail'], 'Mise a jour d\'un événement d\'une adresse dont vous êtes l\'auteur.', $messageDebut.$messageFin, true);
                            } else {
                                $utilisateur->ajouteMailEnvoiRegroupes(array('contenu'=>$messageDebut,'idDestinataire'=>$idUtilisateurAdresse,'idTypeMailRegroupement'=>10));
                            }
                        }
                    }
                }
                // ************************************************************************************************************************************************

                // ************************************************************************************************************************************************
                // envoi au administrateurs qui sont en mode alerteAdresse
                // ************************************************************************************************************************************************

                $message = "";
                $message .= "Un nouvel événement a été ajouté sur l'adresse suivante : <br>";
                $message.="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail','archiIdAdresse'=>$arrayAdresses[0],'archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse))."'>".$adresse->getIntituleAdresseFrom($idSousEvenement, 'idEvenement')."</a>";

                $mail->sendMailToAdministrators($mail->getSiteMail(), "Un nouvel événement a été ajouté - ".$intituleAdresse, $message, " AND alerteAdresses='1' ", true);
                $utilisateur->ajouteMailEnvoiRegroupesAdministrateurs(array('contenu'=>$message,'idTypeMailRegroupement'=>10,'criteres'=>" and alerteAdresses='1' "));
                // ************************************************************************************************************************************************

                // *************************************************************************************************************************************************************
                // envoi mail aussi au moderateur si ajout sur adresse de ville que celui ci modere
                $u = new archiUtilisateur();


                $arrayListeModerateurs = $u->getArrayIdModerateursActifsFromVille($arrayVilles[0], array("sqlWhere"=>" AND alerteAdresses='1' "));
                if (count($arrayListeModerateurs)>0) {
                    foreach ($arrayListeModerateurs as $indice => $idModerateur) {
                        if ($aAuthentification->getIdUtilisateur()!=$idModerateur) {
                            if ($u->isMailEnvoiImmediat($idModerateur)) {
                                $mailModerateur = $u->getMailUtilisateur($idModerateur);
                                $mail->sendMail($mail->getSiteMail(), $mailModerateur, "Un nouvel événement a été ajouté - ".$intituleAdresse, $message, true);
                            } else {
                                $u->ajouteMailEnvoiRegroupes(array('contenu'=>$message,'idDestinataire'=>$idModerateur,'idTypeMailRegroupement'=>10));
                            }
                        }
                    }
                }

                // *************************************************************************************************************************************************************

                if ($idPerson=archiPersonne::isPerson($idEvenementGroupeAdresse)) {
                    header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson), false, false));
                } else {
                    $adresse = new archiAdresse();
                    $idGroupeAdresse = $this->getParent($idSousEvenement);
                    $idAdresse = $this->getIdAdresseFromIdEvenementGroupeAdresse($idGroupeAdresse);

                    $url= $this->creerUrl(
                        '',
                        '',
                        array(
                                'archiAffichage'=>'adresseDetail',
                                "archiIdAdresse"=>$idAdresse,
                                "archiIdEvenementGroupeAdresse"=>$idGroupeAdresse
                        )
                    );
                        header("Location: ".htmlspecialchars_decode($url));
                }
            }
        } else {
            $html .= $this->afficheFormulaire($tabForm);
        }

        return $html;
    }
200872
@Override
	public T save(T entity, boolean validateIntegrityConstraint, boolean preValidateReferentialConstraint, boolean postValidateReferentialConstraint) {
		
		// Si l'entite est nulle
		if(entity == null) throw new JPersistenceToolsException("NullEntityException.message");
		
		// Generation des valeurs
		generateEntityValues(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.PRE_CONDITION);
		
		// Si on doit valider les contraintes d'integrites
		if(validateIntegrityConstraint) validateEntityIntegrityConstraint(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.PRE_CONDITION);
		
		// Si on doit pre-valider les contraintes referentielles
		if(preValidateReferentialConstraint) validateEntityReferentialConstraint(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.PRE_CONDITION);
		
		try {
			
			// Enregistrement
			getEntityManager().persist(entity);
			
		} catch (Exception e) {
			
			// On relance
			throw new JPersistenceToolsException("jpagenericdaorulesbased.save.error", e);
		}
		
		// Validation de l'entite
		if(postValidateReferentialConstraint) validateEntityReferentialConstraint(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.POST_CONDITION);
		
		// On retourne l'entite enregistree
		return entity;
	}