@osimatic/helpers-js 1.0.2

package/date_time.js

@@ -0,0 +1,551 @@
+
+class DateTime {
+
+	static getSqlDate(jsDate, timeZone="Europe/Paris") {
+		let pad = function(num) { return ('00'+num).slice(-2) };
+		// return jsDate.getUTCFullYear() + '-' + pad(jsDate.getUTCMonth() + 1) + '-' + pad(jsDate.getUTCDate());
+		//return jsDate.getFullYear() + '-' + pad(jsDate.getMonth() + 1) + '-' + pad(jsDate.getDate());
+		return jsDate.toLocaleDateString('fr-FR', {year: 'numeric', timeZone: timeZone})+'-'+jsDate.toLocaleDateString('fr-FR', {month: '2-digit', timeZone: timeZone})+'-'+jsDate.toLocaleDateString('fr-FR', {day: '2-digit', timeZone: timeZone});
+	}
+
+	static getSqlTime(jsDate, timeZone="Europe/Paris") {
+		let pad = function(num) { return ('00'+num).slice(-2) };
+		// return pad(jsDate.getUTCHours()) + ':' + pad(jsDate.getUTCMinutes()) + ':' + pad(jsDate.getUTCSeconds());
+		//return pad(jsDate.getHours()) + ':' + pad(jsDate.getMinutes()) + ':' + pad(jsDate.getSeconds());
+		return pad(jsDate.toLocaleTimeString('en-GB', {hour: 'numeric', timeZone: timeZone}))+':'+pad(jsDate.toLocaleTimeString('en-GB', {minute: 'numeric', timeZone: timeZone}))+':'+pad(jsDate.toLocaleTimeString('en-GB', {second: 'numeric', timeZone: timeZone}));
+	}
+
+	static getSqlDateTime(jsDate) {
+		return this.getSqlDate(jsDate)+' '+this.getSqlTime(jsDate);
+	}
+
+	static getTimestamp(jsDate) {
+		return jsDate.getTime();
+	}
+
+	static getDateDigitalDisplay(jsDate, locale="fr-FR", timeZone="Europe/Paris") {
+		return jsDate.toLocaleDateString(locale, {year: 'numeric', month: 'numeric', day: 'numeric', timeZone: timeZone});
+	}
+	static getDateTextDisplay(jsDate, locale="fr-FR", timeZone="Europe/Paris") {
+		return jsDate.toLocaleDateString(locale, {weekday: 'long', year: 'numeric', month: 'long', day: 'numeric', timeZone: timeZone});
+	}
+
+	static getTimeDisplay(jsDate, locale="fr-FR", timeZone="Europe/Paris") {
+		return jsDate.toLocaleTimeString(locale, {hour: 'numeric', minute: 'numeric', timeZone: timeZone});
+	}
+	static getTimeDigitalDisplay(jsDate, locale="fr-FR", timeZone="Europe/Paris") {
+		return jsDate.toLocaleTimeString(locale, {hour: '2-digit', minute: '2-digit', second: '2-digit', timeZone: timeZone});
+	}
+	static getTimeDisplayWithNbDays(jsDate, jsPreviousDate, locale="fr-FR", timeZone="Europe/Paris") {
+		let str = this.getTimeDisplay(jsDate, locale, timeZone);
+		if (jsPreviousDate != 0 && jsPreviousDate != null) {
+			let nbDaysDiff = this.getNbDayBetweenTwo(jsPreviousDate, jsDate, false);
+			if (nbDaysDiff > 0) {
+				str += ' (J+'+nbDaysDiff+')';
+			}
+		}
+		return str;
+	}
+
+	static getDateTimeDigitalDisplay(jsDate, locale="fr-FR", timeZone="Europe/Paris") {
+		return jsDate.toLocaleDateString(locale, {year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', timeZone: timeZone});
+	}
+
+	static getYear(jsDate) {
+		return jsDate.getUTCFullYear();
+	}
+	static getMonth(jsDate) {
+		return jsDate.getUTCMonth()+1;
+	}
+	static getMonthName(jsDate, locale="fr-FR", isShort=false) {
+		return jsDate.toLocaleDateString(locale, {month: (isShort?'short':'long')});
+	}
+	static getDay(jsDate) {
+		return jsDate.getUTCDate();
+	}
+	
+	static getDayOfMonth(jsDate) {
+		return jsDate.getUTCDate();
+	}
+	
+	static getDayOfWeek(jsDate) {
+		return jsDate.getUTCDay();
+	}
+	
+	static getDayName(jsDate, locale="fr-FR", isShort=false) {
+		return jsDate.toLocaleDateString(locale, {weekday: (isShort?'short':'long')});
+	}
+
+	static getNbDaysInMonth(year, month) {
+		return new Date(year, month, 0).getDate();
+	}
+
+	static getMonthNameByMonth(month, locale="fr-FR", isShort=false) {
+		let d = new Date();
+		d.setDate(1);
+		d.setMonth(month-1);
+		return this.getMonthName(d, locale, isShort);
+	}
+	static getDayNameByDayOfWeek(dayOfWeek, locale="fr-FR", isShort=false) {
+		let d = new Date();
+		// d.setDate(d.getDate() + (1 + 7 - d.getDay()) % 7);
+		d.setDate(d.getDate() + (dayOfWeek - d.getDay()) % 7);
+		return this.getDayName(d, locale, isShort);
+	}
+
+
+	static getFirstDayOfWeek(date) {
+		let firstDayOfWeek = new Date(date);
+		firstDayOfWeek.setDate(date.getDate() - date.getDay() + 1); // First day is the day of the month - the day of the week
+		return firstDayOfWeek;
+	}
+
+	static getLastDayOfWeek(date) {
+		let lastDayOfWeek = this.getFirstDayOfWeek(date);
+		lastDayOfWeek.setDate(lastDayOfWeek.getDate() + 6); // last day is the first day + 6
+		return lastDayOfWeek;
+	}
+
+	static getFirstDayOfMonth(date) {
+		return this.getFirstDayOfMonthAndYear(date.getFullYear(), date.getMonth()+1);
+	}
+
+	static getLastDayOfMonth(date) {
+		return this.getLastDayOfMonthAndYear(date.getFullYear(), date.getMonth()+1);
+	}
+
+	static getFirstDayOfYear(date) {
+		date.setDate(1);
+		date.setMonth(0);
+		return new Date(date);
+	}
+
+	static getLastDayOfYear(date) {
+		date.setDate(31);
+		date.setMonth(11);
+		return new Date(date);
+	}
+
+	static getFirstDayOfWeekAndYear(year, week) {
+		let simple = new Date(year, 0, 1 + (week - 1) * 7);
+		let dow = simple.getDay();
+		let ISOweekStart = simple;
+		if (dow <= 4) {
+			ISOweekStart.setDate(simple.getDate() - simple.getDay() + 1);
+		}
+		else {
+			ISOweekStart.setDate(simple.getDate() + 8 - simple.getDay());
+		}
+		return ISOweekStart;
+	}
+	static getLastDayOfWeekAndYear(year, week) {
+		let firstDayOfWeek = this.getFirstDayOfWeekAndYear(year, week);
+		firstDayOfWeek.setDate(firstDayOfWeek.getDate()+6);
+		return firstDayOfWeek;
+	}
+
+	static getFirstDayOfMonthAndYear(year, month) {
+		return new Date(year, month-1, 1);
+	}
+
+	static getLastDayOfMonthAndYear(year, month) {
+		return new Date(year, month, 0);
+	}
+
+	static isDateEqual(jsDate1, jsDate2) {
+		return (jsDate1.getFullYear() == jsDate2.getFullYear() && jsDate1.getMonth() == jsDate2.getMonth() && jsDate1.getDate() == jsDate2.getDate());
+	}
+
+	static isDateInTheFuture(jsDate) {
+		jsDate.setHours(0);
+		jsDate.setMinutes(0);
+		jsDate.setSeconds(0);
+		let today = new Date();
+		today.setHours(0);
+		today.setMinutes(0);
+		today.setSeconds(0);
+		return jsDate.getTime() > today.getTime();
+	}
+
+	static isDateTimeInTheFuture(jsDateTime) {
+		let today = new Date();
+		return jsDateTime > today;
+	}
+
+	static getNbDayBetweenTwo(jsDate1, jsDate2, asPeriod, timeZone="Europe/Paris") {
+		//jsDate1.set
+		if (jsDate1 == null || jsDate2 == null) {
+			return 0;
+		}
+
+		let timestamp1 = jsDate1.getTime() / 1000;
+		let timestamp2 = jsDate2.getTime() / 1000;
+
+		if (!asPeriod) {
+			let jsMidnightDate1 = new Date(jsDate1.toLocaleDateString('en-US', {timeZone: timeZone})+' 00:00:00');
+			let jsMidnightDate2 = new Date(jsDate2.toLocaleDateString('en-US', {timeZone: timeZone})+' 00:00:00');
+			timestamp1 = jsMidnightDate1.getTime() / 1000;
+			timestamp2 = jsMidnightDate2.getTime() / 1000;
+			//jsDate1.setHours(0, 0, 0);
+			//jsDate2.setHours(0, 0, 0);
+			//jsDate1.setUTCHours(0, 0, 0);
+			//jsDate2.setUTCHours(0, 0, 0);
+		}
+		return parseInt(Math.round((timestamp2-timestamp1)/86400));
+	}
+}
+
+class TimestampUnix {
+	static parse(timestamp) {
+		if (timestamp == null) {
+			return null;
+		}
+		return new Date(parseInt(timestamp+'000'));
+	}
+
+	static getCurrent() {
+		let today = new Date();
+		return parseInt(today.getTime() / 1000);
+	}
+
+	static getDateDigitalDisplay(timestamp, locale="fr-FR", timeZone="Europe/Paris") {
+		return DateTime.getDateDigitalDisplay(this.parse(timestamp), locale, timeZone);
+	}
+	static getDateTextDisplay(timestamp, locale="fr-FR", timeZone="Europe/Paris") {
+		return DateTime.getDateTextDisplay(this.parse(timestamp), locale, timeZone);
+	}
+
+	static getTimeDisplay(timestamp, locale="fr-FR", timeZone="Europe/Paris") {
+		return DateTime.getTimeDisplay(this.parse(timestamp), locale, timeZone);
+	}
+	static getTimeDisplayWithNbDays(timestamp, previousTimestamp, locale="fr-FR", timeZone="Europe/Paris") {
+		return DateTime.getTimeDisplayWithNbDays(this.parse(timestamp), this.parse(previousTimestamp), locale, timeZone);
+	}
+	static getTimeDigitalDisplay(timestamp, locale="fr-FR", timeZone="Europe/Paris") {
+		return DateTime.getTimeDigitalDisplay(this.parse(timestamp), locale, timeZone);
+	}
+
+	static getYear(timestamp, timeZone="Europe/Paris") {
+		return this.parse(timestamp).toLocaleDateString('fr-FR', {year: 'numeric', timeZone: timeZone});
+	}
+	static getMonth(timestamp, timeZone="Europe/Paris") {
+		return this.parse(timestamp).toLocaleDateString('fr-FR', {month: 'numeric', timeZone: timeZone});
+	}
+	static getDayOfMonth(timestamp, timeZone="Europe/Paris") {
+		return this.parse(timestamp).toLocaleDateString('fr-FR', {day: 'numeric', timeZone: timeZone});
+	}
+
+	static getHour(timestamp, timeZone="Europe/Paris") {
+		return this.parse(timestamp).toLocaleTimeString('en-GB', {hour: 'numeric', timeZone: timeZone});
+	}
+	static getMinute(timestamp, timeZone="Europe/Paris") {
+		return this.parse(timestamp).toLocaleTimeString('en-GB', {minute: 'numeric', timeZone: timeZone});
+	}
+	static getSecond(timestamp, timeZone="Europe/Paris") {
+		return this.parse(timestamp).toLocaleTimeString('en-GB', {second: 'numeric', timeZone: timeZone});
+	}
+
+	static getSqlDateTime(timestamp, timeZone="Europe/Paris") {
+		return this.getSqlDate(timestamp, timeZone)+' '+this.getSqlTime(timestamp, timeZone);
+	}
+	static getSqlDate(timestamp, timeZone="Europe/Paris") {
+		return DateTime.getSqlDate(this.parse(timestamp), timeZone);
+	}
+	static getSqlTime(timestamp, timeZone="Europe/Paris") {
+		return DateTime.getSqlTime(this.parse(timestamp), timeZone);
+	}
+
+	static isDateEqual(timestamp1, timestamp2) {
+		return DateTime.isDateEqual(this.parse(timestamp1), this.parse(timestamp2));
+	}
+
+	static getNbDayBetweenTwo(timestamp1, timestamp2, asPeriod, timeZone="Europe/Paris") {
+		return DateTime.getNbDayBetweenTwo(this.parse(timestamp1), this.parse(timestamp2), asPeriod, timeZone);
+	}
+
+	static isDateInTheFuture(timestamp) {
+		return DateTime.isDateInTheFuture(this.parse(timestamp));
+	}
+	static isDateTimeInTheFuture(timestamp) {
+		return DateTime.isDateTimeInTheFuture(this.parse(timestamp));
+	}
+
+}
+
+class SqlDate {
+	static parse(sqlDate) {
+		if (sqlDate == null) {
+			return null;
+		}
+		return new Date(sqlDate.substring(0, 4), sqlDate.substring(5, 7)-1, sqlDate.substring(8, 10), 0, 0, 0);
+	}
+
+	static getCurrentSqlDate() {
+		return DateTime.getSqlDate(new Date());
+	}
+
+	static getDateDigitalDisplay(sqlDate, locale="fr-FR") {
+		return SqlDateTime.getDateDigitalDisplay(sqlDate+" 00:00:00", locale);
+	}
+	static getDateTextDisplay(sqlDate, locale="fr-FR") {
+		return SqlDateTime.getDateTextDisplay(sqlDate+" 00:00:00", locale);
+	}
+
+	static getYear(sqlDate) {
+		return SqlDateTime.getYear(sqlDate+" 00:00:00");
+	}
+	static getMonth(sqlDate) {
+		return SqlDateTime.getMonth(sqlDate+" 00:00:00");
+	}
+	static getMonthName(sqlDate, locale="fr-FR", isShort=false) {
+		return SqlDateTime.getMonthName(sqlDate+" 00:00:00", locale, isShort);
+	}
+	static getDay(sqlDate) {
+		return SqlDateTime.getDay(sqlDate+" 00:00:00");
+	}
+
+	static isDateInTheFuture(sqlDate) {
+		return DateTime.isDateInTheFuture(SqlDateTime.parse(sqlDate + " 00:00:00"));
+	}
+
+}
+
+class SqlTime {
+	static parse(sqlTime) {
+		if (sqlTime == null) {
+			return null;
+		}
+		
+		if ((sqlTime.match(/\:/g) || []).length == 1) {
+			sqlTime += ':00';
+		}
+		let jsDate = new Date();
+		let arrayTime = sqlTime.split(':');
+		jsDate.setHours(arrayTime[0], arrayTime[1], arrayTime[2], 0);
+		return jsDate;
+	}
+
+	static getCurrentSqlTime() {
+		return DateTime.getSqlTime(new Date());
+	}
+
+	static getTimeDisplay(sqlTime, locale="fr-FR") {
+		return SqlDateTime.getTimeDisplay('1970-01-01 '+sqlTime, locale);
+	}
+	static getTimeDigitalDisplay(sqlTime, locale="fr-FR") {
+		return SqlDateTime.getTimeDigitalDisplay('1970-01-01 '+sqlTime, locale);
+	}
+	static getTimeDisplayWithNbDays(sqlTime, previousSqlTime) {
+		return SqlDateTime.getTimeDisplayWithNbDays('1970-01-01 '+sqlTime, '1970-01-01 '+previousSqlTime, locale);
+	}
+}
+
+class SqlDateTime {
+	static getCurrentSqlDateTime() {
+		return DateTime.getSqlDateTime(new Date());
+	}
+
+	static getSqlDate(sqlDateTime) {
+		if (sqlDateTime == null) {
+			return null;
+		}
+		return DateTime.getSqlDate(this.parse(sqlDateTime));
+	}
+
+	static getSqlTime(sqlDateTime) {
+		if (sqlDateTime == null) {
+			return null;
+		}
+		return DateTime.getSqlTime(this.parse(sqlDateTime));
+	}
+
+	static parse(sqlDateTime) {
+		if (sqlDateTime == null) {
+			return null;
+		}
+		return new Date(sqlDateTime.substring(0, 4), sqlDateTime.substring(5, 7)-1, sqlDateTime.substring(8, 10), sqlDateTime.substring(11, 13), sqlDateTime.substring(14, 16), sqlDateTime.substring(17, 19));
+	}
+
+	static getDateDigitalDisplay(sqlDateTime, locale="fr-FR") {
+		return DateTime.getDateDigitalDisplay(this.parse(sqlDateTime), locale);
+	}
+	static getDateTextDisplay(sqlDateTime, locale="fr-FR") {
+		return DateTime.getDateTextDisplay(this.parse(sqlDateTime), locale);
+	}
+
+	static getTimeDisplay(sqlDateTime, locale="fr-FR") {
+		return DateTime.getTimeDisplay(this.parse(sqlDateTime), locale);
+	}
+	static getTimeDisplayWithNbDays(sqlDateTime, previousSqlDateTime) {
+		return DateTime.getTimeDisplayWithNbDays(this.parse(sqlDateTime), this.parse(previousSqlDateTime), locale);
+	}
+	static getTimeDigitalDisplay(sqlDateTime, locale="fr-FR") {
+		return DateTime.getTimeDigitalDisplay(this.parse(sqlDateTime), locale);
+	}
+
+	static getDateTimeDigitalDisplay(sqlDateTime, locale="fr-FR") {
+		return DateTime.getDateTimeDigitalDisplay(this.parse(sqlDateTime), locale);
+	}
+
+	static getYear(sqlDateTime) {
+		return DateTime.getYear(this.parse(sqlDateTime));
+	}
+	static getMonth(sqlDateTime) {
+		return DateTime.getMonth(this.parse(sqlDateTime));
+	}
+	static getMonthName(sqlDateTime, locale="fr-FR", isShort=false) {
+		return DateTime.getMonthName(this.parse(sqlDateTime), locale);
+	}
+	static getDay(sqlDateTime) {
+		return DateTime.getDay(this.parse(sqlDateTime));
+	}
+
+	static getTimestamp(sqlDateTime) {
+		return DateTime.getTimestamp(this.parse(sqlDateTime));
+	}
+
+	static isDateInTheFuture(sqlDateTime) {
+		return DateTime.isDateInTheFuture(this.parse(sqlDateTime));
+	}
+
+	static isDateTimeInTheFuture(sqlDateTime) {
+		return DateTime.isDateTimeInTheFuture(this.parse(sqlDateTime));
+	}
+
+	static getNbDayBetweenTwo(sqlDateTime1, sqlDateTime2, asPeriod) {
+		return DateTime.getNbDayBetweenTwo(this.parse(sqlDateTime1), this.parse(sqlDateTime2), asPeriod);
+	}
+
+}
+
+
+class InputPeriod {
+
+	static addLinks(form) {
+		let divParent = form.find('input[type="date"][data-add_period_select_links]').parent();
+		if (divParent.hasClass('input-group')) {
+			divParent = divParent.parent();
+		}
+		divParent.append(''
+			+'<div class="select_period_links">'
+				+'<a href="#" class="period_select_yesterday">Hier</a> - '
+				+'<a href="#" class="period_select_current_week">Cette semaine</a> - '
+				+'<a href="#" class="period_select_last_week">La semaine dernière</a> - '
+				+'<a href="#" class="period_select_current_month">Ce mois-ci</a> - '
+				+'<a href="#" class="period_select_last_month">Le mois dernier</a> - '
+				+'<a href="#" class="period_select_current_year">Cette année</a>'
+			+'</div>'
+		);
+		this.init(form);
+	}
+
+	static init(form) {
+		let link;
+		//console.log(form.find('a.period_select_current_week'));
+
+		if ((link = form.find('a.period_select_today')).length) {
+			link.click(function() { InputPeriod.selectToday($(this)); return false; });
+		}
+		if ((link = form.find('a.period_select_yesterday')).length) {
+			link.click(function() { InputPeriod.selectPreviousDay($(this), 1); return false; });
+		}
+		if ((link = form.find('a.period_select_tomorrow')).length) {
+			link.click(function() { InputPeriod.selectFollowingDay($(this), 1); return false; });
+		}
+		if ((link = form.find('a.period_select_current_week')).length) {
+			link.click(function() { InputPeriod.selectCurrentWeek($(this)); return false; });
+		}
+		if ((link = form.find('a.period_select_last_week')).length) {
+			link.click(function() { InputPeriod.selectPreviousWeek($(this), 1); return false; });
+		}
+		if ((link = form.find('a.period_select_current_month')).length) {
+			link.click(function() { InputPeriod.selectCurrentMonth($(this)); return false; });
+		}
+		if ((link = form.find('a.period_select_last_month')).length) {
+			link.click(function() { InputPeriod.selectPreviousMonth($(this), 1); return false; });
+		}
+		if ((link = form.find('a.period_select_current_year')).length) {
+			link.click(function() { InputPeriod.selectCurrentYear($(this)); return false; });
+		}
+		if ((link = form.find('a.period_select_last_year')).length) {
+			link.click(function() { InputPeriod.selectCurrentYear($(this), 1); return false; });
+		}
+	}
+	
+
+	static selectToday(link) {
+		let date = new Date();
+		this.selectPeriod(link, date, date);
+	}
+	
+	static selectPreviousDay(lien, nbDays) {
+		this.selectFollowingDay(lien, -nbDays);
+	}
+	static selectFollowingDay(lien, nbDays) {
+		let date = new Date();
+		date.setDate(date.getDate() + nbDays);
+		this.selectPeriod(lien, date, date);
+	}
+	
+	static selectCurrentWeek(lien) {
+		let date = new Date();
+		this.selectPeriod(lien, DateTime.getFirstDayOfWeek(date), DateTime.getLastDayOfWeek(date));
+	}
+	static selectPreviousWeek(lien, nbWeeks) {
+		this.selectFollowingWeek(lien, -nbWeeks);
+	}
+	static selectFollowingWeek(lien, nbWeeks) {
+		let date = new Date();
+		date.setDate(date.getDate() + (7*nbWeeks));
+		this.selectPeriod(lien, DateTime.getFirstDayOfWeek(date), DateTime.getLastDayOfWeek(date));
+	}
+	
+	static selectCurrentMonth(lien) {
+		let date = new Date();
+		this.selectPeriod(lien, DateTime.getFirstDayOfMonth(date), DateTime.getLastDayOfMonth(date));
+	}
+	static selectPreviousMonth(lien, nbMonths) {
+		this.selectFollowingMonth(lien, -nbMonths);
+	}
+	static selectFollowingMonth(lien, nbMonths) {
+		let date = new Date();
+		date.setDate(1);
+		date.setMonth(date.getMonth() + nbMonths);
+		this.selectPeriod(lien, DateTime.getFirstDayOfMonth(date), DateTime.getLastDayOfMonth(date));
+	}
+	
+	static selectCurrentYear(lien) {
+		this.selectFollowingYear(lien, 0);
+	}
+	static selectPreviousYear(lien, nbAnneesMoins) {
+		this.selectFollowingYear(lien, -nbAnneesMoins);
+	}
+	static selectFollowingYear(lien, nbAnneesMoins) {
+		let date = new Date();
+		date.setFullYear(date.getFullYear() + nbAnneesMoins);
+		this.selectPeriod(lien, DateTime.getFirstDayOfYear(date), DateTime.getLastDayOfYear(date));
+	}
+	
+
+	static selectPeriod(link, startDate, endDate) {
+		let inputPeriodStart = link.parent().parent().find('input[type="date"]').filter('[name="date_start"], [name="start_date"], [name="start_period"], [name="period_start_date"]');
+		let inputPeriodEnd = link.parent().parent().find('input[type="date"]').filter('[name="date_end"], [name="end_date"], [name="end_period"], [name="period_end_date"]');
+		if (inputPeriodStart.length == 0 || inputPeriodEnd.length == 0) {
+			console.log('no period input found');
+			return;
+		}
+
+		//console.log(startDate);
+		//console.log(endDate);
+		inputPeriodStart.val(DateTime.getSqlDate(startDate));
+		inputPeriodEnd.val(DateTime.getSqlDate(endDate));
+	}
+	
+}
+
+exports.DateTime = DateTime;
+exports.TimestampUnix = TimestampUnix;
+exports.SqlDate = SqlDate;
+exports.SqlTime = SqlTime;
+exports.SqlDateTime = SqlDateTime;
+exports.InputPeriod = InputPeriod;

package/details_sub_array.js

@@ -0,0 +1,126 @@
+class DetailsSubArray {
+
+	static initDetailsLink(table, callbackOnDetailsActionRequestSuccess, callbackOnDetailsActionRequestError, callbackOnDetailsActionRequestBeforeSend) {
+		function getNbColumns(tr) {
+			return tr.closest('table').find('thead tr').children().length;
+		}
+		function displayErrorRow(tr) {
+			tr.after($('<tr class="text-error"><td colspan="'+getNbColumns(tr)+'">'+labelErrorOccured+'</td></tr>'));
+		}
+		function displayDetailsRow(tr, content) {
+			var trContent = $(''
+				+ '<tr class="participants">'
+				+ '<td colspan="'+getNbColumns(tr)+'">'
+				+ '</td>'
+				+ '</tr>'
+			);
+			trContent.find('td').append(content);
+			tr.after(trContent);
+		}
+
+		function hideDetailsRow(link) {
+			var tr = link.closest('tr').addClass('folded');
+			if (tr.next().hasClass('participants') ) {
+				tr.next().remove();
+			}
+			showPlusButton(link);
+		}
+
+		function showPlusButton(link) {
+			link.prop('title', showDetailsLabel).attr('disabled', false).html($('<span class="glyphicon glyphicon-plus" aria-hidden="true"></span>'));
+		}
+		function showMinusButton(link) {
+			link.prop('title', hideDetailsLabel).attr('disabled', false).html($('<span class="glyphicon glyphicon-minus" aria-hidden="true"></span>'));
+		}
+
+		function displayLoading(link) {
+			link.attr('disabled', true).html($('<i class="fa fa-circle-notch fa-spin"></i>'));
+			var tr = link.closest('tr');
+			tr.after($('<tr class="waiting_icon"><td colspan="'+getNbColumns(tr)+'" class="center"><i class="fa fa-circle-notch fa-spin"></i></td></tr>'));
+		}
+		function hideLoading(link) {
+			// todo : cacher que le loader du lien au lieu de tous les loaders (cas ou l'user clique sur tous les boutons rapidement)
+			if ($('tr.waiting_icon').length > 0) {
+				$(('tr.waiting_icon')).remove();
+			}
+		}
+
+		function setHideDetailsLink(link) {
+			showMinusButton(link);
+			link.click(function() {
+				$(this).stop();
+				hideDetailsRow(link);
+				setDisplayDetailsLink(link);
+				return false;
+			});
+		}
+
+		function setDisplayDetailsLink(link) {
+			link.click(function() {
+				$(this).stop().off('click');
+				hideDetailsRow(link);
+				doDetailsActionRequest(link);
+				return false;
+			});
+		}
+
+		function doDetailsActionRequest(link) {
+			displayLoading(link);
+
+			if (typeof callbackOnDetailsActionRequestBeforeSend != 'undefined' && callbackOnDetailsActionRequestBeforeSend != null) {
+				displayDetailsRow(link.closest('tr'), callbackOnDetailsActionRequestBeforeSend(link));
+				hideLoading(link);
+				setHideDetailsLink(link);
+				return;
+			}
+
+			//link.attr('disabled', true).button('loading');
+			$.ajax({
+				url: link.data("url_details"),
+				method: 'GET',
+				headers: httpHeaders,
+				cache: false,
+				dataType: 'json',
+				success: function (jsonObj) {
+					if (jsonObj == null) {
+						if (typeof callbackOnDetailsActionRequestError != 'undefined' && callbackOnDetailsActionRequestError != null) {
+							callbackOnDetailsActionRequestError(link);
+							return;
+						}
+						displayErrorRow(link.closest('tr'));
+						return;
+					}
+
+					if (typeof callbackOnDetailsActionRequestSuccess != 'undefined' && callbackOnDetailsActionRequestSuccess != null) {
+						displayDetailsRow(link.closest('tr'), callbackOnDetailsActionRequestSuccess(jsonObj, link));
+					}
+				},
+				error: function (jqxhr, status, exception) {
+					console.log('Detail request failure. Status: '+status+' ; Exception: '+exception);
+
+					if (typeof callbackOnDetailsActionRequestError != 'undefined' && callbackOnDetailsActionRequestError != null) {
+						callbackOnDetailsActionRequestError(link);
+						return;
+					}
+
+					link.closest('tr').after($('<tr class="error"><td colspan="6" class="center">'+labelErrorOccured+'</td></tr>'));
+					//window.location.replace(decodeURIComponent(urlRetour));
+				},
+				complete: function() {
+					hideLoading(link);
+					setHideDetailsLink(link);
+					//link.attr('disabled', false).button('reset');
+				}
+			});
+		}
+
+		table.find('a.details_link').each(function(idx, link) {
+			$(link).removeClass('hide');
+			setDisplayDetailsLink($(link));
+			showPlusButton($(link));
+		});
+	}
+
+}
+
+exports.DetailsSubArray = DetailsSubArray;