Browse Source

Statistiques + graphe

Arthur Brandao 5 years ago
parent
commit
d13ec85c8f

+ 122 - 59
WebContent/index.jsp

@@ -1,6 +1,12 @@
 <%@ page language="java" contentType="text/html; charset=UTF-8"
 	pageEncoding="utf-8"%>
 <%@ taglib prefix="tag" tagdir="/WEB-INF/tags" %>
+<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
+
+<c:set var="req" value="${pageContext.request}" />
+<c:set var="url">${req.requestURL}</c:set>
+<c:set var="base" value="${fn:substring(url, 0, fn:length(url) - fn:length(req.requestURI))}${req.contextPath}/" />
 
 <!DOCTYPE html>
 <html>
@@ -22,89 +28,146 @@
         </div>
         <div class="row">
             <div class="col m12 l6">
-                <canvas id="espaceToday"></canvas>
+                <canvas id="chart1"></canvas>
             </div>
             <div class="col m12 l6">
-                <canvas id="espaceMonth"></canvas>
+                <canvas id="chart2"></canvas>
             </div>
         </div>
         <div class="row mtop-2">
             <div class="col m12 l6">
-                <canvas id="freqWeek"></canvas>
+                <canvas id="chart3"></canvas>
             </div>
             <div class="col m12 l6">
-                <canvas id="freqHours"></canvas>
+                <canvas id="chart4"></canvas>
             </div>
         </div>
     </main>
 
     <!-- Footer -->
     <tag:footer />
+    
+    <!-- Loader -->
+    <tag:loader name="loader" />
 
     <!-- Script -->
     <tag:script />
     <script type="text/javascript" src="js/chart.min.js"></script>
     <script type="text/javascript" src="js/generate-chart.js"></script>
     <script type="text/javascript">
-        $(document).ready(() => {
-            generateBarChart(
-                document.getElementById('espaceToday'),
-                'Fréquentation des espaces aujourd\'hui',
-                ["Accueil", "Realite Virtuelle", "Musee Numerique", "Cyber Base", "Shooting Photo", "Jeux Videos", "Espace Scenique"],
-                [{
-                    title: 'Actuel',
-                    value: [60, 46, 30, 28, 22, 35, 9],
-                    color: { r: 255, g: 99, b: 132 }
+    	function weekChart(id, callback = null) {
+   		 	$.ajax({
+                type: "GET",
+                url: "${base}api/frequentation/stats/week",
+                error: () => {
+					console.error("Impossible de charger ageChart");
+					if (callback != null) {
+              			callback();
+              	 	}
+                },
+                success: (result) => {
+                	const data = result.data;
+               	 	generateBarChart(
+                    	document.getElementById(id),
+                       	data.title,
+                       	["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"],
+                       	data.stats
+                    );
+               	 if (callback != null) {
+               		 callback();
+               	 }
                 },
-                {
-                    title: 'Moyenne 2019',
-                    value: [88, 42, 21, 34, 19, 38, 11],
-                    color: { r: 235, g: 192, b: 52 }
-                }]
-            );
-            generateBarChart(
-                document.getElementById('espaceMonth'),
-                'Fréquentation des espaces ce mois-ci',
-                ["Accueil", "Realite Virtuelle", "Musee Numerique", "Cyber Base", "Shooting Photo", "Jeux Videos", "Espace Scenique"],
-                [{
-                    title: 'Actuel',
-                    value: [260, 146, 90, 128, 112, 235, 109],
-                    color: { r: 255, g: 99, b: 132 }
+            });
+   		};
+    	
+    	function ageChart(id, callback = null) {
+    		 $.ajax({
+                 type: "GET",
+                 url: "${base}api/frequentation/stats/age",
+                 error: () => {
+					console.error("Impossible de charger ageChart");
+					if (callback != null) {
+               			callback();
+               	 	}
+                 },
+                 success: (result) => {
+                	 const data = result.data;
+                	 generateBarChart(
+                     	document.getElementById(id),
+                        data.title,
+                        data.labels,
+                        data.stats
+                     );
+                	 if (callback != null) {
+                		 callback();
+                	 }
+                 },
+             });
+    	};
+    	
+    	function espaceWeekChart(id, callback = null) {
+   		 	$.ajax({
+                type: "GET",
+                url: "${base}api/frequentation/stats/espace/week",
+                error: () => {
+					console.error("Impossible de charger ageChart");
+					if (callback != null) {
+              			callback();
+              	 	}
                 },
-                {
-                    title: 'Moyenne 2019',
-                    value: [260, 142, 157, 132, 101, 191, 118],
-                    color: { r: 235, g: 192, b: 52 }
-                }]
-            );
-            generateBarChart(
-                document.getElementById('freqWeek'),
-                'Fréquentation par jours',
-                ["Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"],
-                [{
-                    title: 'Actuel',
-                    value: [60, 46, 30, 28, 22]
+                success: (result) => {
+                	const data = result.data;
+               	 	generateBarChart(
+                    	document.getElementById(id),
+                       	data.title,
+                       	data.labels,
+                       	data.stats
+                    );
+               	 if (callback != null) {
+               		 callback();
+               	 }
                 },
-                {
-                    title: 'Moyenne 2019',
-                    value: [88, 42, 21, 34, 19],
-                    line: true
-                }]
-            );
-            generateBarChart(
-                document.getElementById('freqHours'),
-                'Fréquentation par heures',
-                ["09H00-11H00", "11H00-13H00", "13H00-15H00", "15H00-17H00", "17H00-19H00"],
-                [{
-                    title: 'Actuel',
-                    value: [10, 8, 4, 20, 12],
+            });
+   		};
+   		
+   		function espaceMonthChart(id, callback = null) {
+   		 	$.ajax({
+                type: "GET",
+                url: "${base}api/frequentation/stats/espace/month",
+                error: () => {
+					console.error("Impossible de charger ageChart");
+					if (callback != null) {
+              			callback();
+              	 	}
                 },
-                {
-                    title: 'Moyenne 2019',
-                    value: [14, 6, 5, 18, 14],
-                    line: true
-                }]
-            );
+                success: (result) => {
+                	const data = result.data;
+               	 	generateBarChart(
+                 	   	document.getElementById(id),
+                       	data.title,
+                       	data.labels,
+                       	data.stats
+                    );
+               	 if (callback != null) {
+               		 callback();
+               	 }
+                },
+            });
+   		};
+    
+        $(document).ready(() => {
+        	const loader = M.Modal.getInstance($('#loader'));
+        	loader.open();
+        	weekChart("chart1", () => {
+        		ageChart("chart2", () => {
+        			espaceWeekChart("chart3", () => {
+        				espaceMonthChart("chart4", () => {
+        					loader.close();
+        				})
+        			})
+        		});
+        	})
+            
         });
     </script>
 </body>

+ 1 - 1
WebContent/settings/index.jsp

@@ -32,7 +32,7 @@
         <div class="row center-align">
         	<c:forEach items="<%= espaces %>" var="espace">
 	        	<div class="col l4 m6 s12 mbot-5">
-	                <a href="<c:url value="/settings/configure?espace=${espace.code}&nom=${espace.libelle}"/>" class="waves-effect waves-light btn-large red">${espace.libelle}</a>
+	                <a href="<c:url value="/settings/configure?espace=${espace.code}"/>" class="waves-effect waves-light btn-large red">${espace.libelle}</a>
 	            </div>
         	</c:forEach>
         </div>

+ 194 - 0
src/microfolie/entry/rest/FrequentationController.java

@@ -0,0 +1,194 @@
+package microfolie.entry.rest;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Logger;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import microfolie.service.FrequentationService;
+import microfolie.service.dto.FrequentationDTO;
+import microfolie.utils.JsonUtils;
+
+@Path("/frequentation")
+@Produces("application/json")
+public class FrequentationController {
+
+	private static final Logger LOGGER = Logger.getLogger(FrequentationController.class.getName());
+	
+	private FrequentationService service = FrequentationService.getInstance();
+	
+	@GET
+	@Path("/stats/week")
+	public String statsByWeek() {
+		JSONObject data = new JSONObject();
+		JSONArray stats = new JSONArray();
+		LOGGER.info("Begin: Stats by week");
+		// Récuperation info
+		Map<Date, List<FrequentationDTO>> week = service.getByDayOfWeek(0);
+		Map<Date, List<FrequentationDTO>> lastWeek = service.getByDayOfWeek(1);
+		// Creation statistique semaine courante + récupération clef
+		final JSONArray labels = new JSONArray();
+		final JSONArray value = new JSONArray();
+		week.forEach((key, val) -> {
+			labels.put(key.toString());
+			value.put(val.stream().count());
+		});
+		JSONObject json = new JSONObject();
+		json.put("title", "Semaine courante");
+		json.put("value", value);
+		json.put("color", new JSONObject("{ \"r\": 255, \"g\": 99, \"b\": 132 }"));
+		stats.put(json);
+		// Creation statistique semaine derniere
+		final JSONArray valueLast = new JSONArray();
+		lastWeek.forEach((key, val) -> {
+			valueLast.put(val.stream().count());
+		});
+		json = new JSONObject();
+		json.put("title", "Semaine derniere");
+		json.put("value", valueLast);
+		json.put("color", new JSONObject("{ \"r\": 235, \"g\": 192, \"b\": 52 }"));
+		json.put("line", true);
+		stats.put(json);
+		LOGGER.info("End: Stats by week");
+		data.put("title", "Frequentation de la semaine");
+		data.put("labels", labels);
+		data.put("stats", stats);
+		return JsonUtils.success(data).toString();
+	}
+	
+	@GET
+	@Path("/stats/age")
+	public String statsByAge() {
+		JSONObject data = new JSONObject();
+		JSONArray stats = new JSONArray();
+		LOGGER.info("Begin: Stats by age");
+		Map<String, Map<Integer, List<FrequentationDTO>>> freqs = service.getByAgeOnEspace(0);
+		Map<Integer, Map<String, List<FrequentationDTO>>> tmp = new HashMap<>();
+		// Pour chaque espace
+		JSONArray labels = new JSONArray();
+		List<String> espaces = new ArrayList<>();
+		freqs.forEach((espace, freq) -> {
+			labels.put(espace);
+			espaces.add(espace);
+		});
+		freqs.forEach((espace, freq) -> {
+			freq.forEach((age, f) -> {
+				if (tmp.containsKey(age)) {
+					Map<String, List<FrequentationDTO>> tmpMap = tmp.get(age);
+					List<FrequentationDTO> tmpList = tmpMap.get(espace);
+					f.forEach(elt -> tmpList.add(elt));
+				} else {
+					Map<String, List<FrequentationDTO>> tmpMap = new HashMap<>();
+					espaces.forEach(elt -> tmpMap.put(elt, new ArrayList<>()));
+					List<FrequentationDTO> tmpList = tmpMap.get(espace);
+					f.forEach(elt -> tmpList.add(elt));
+					tmp.put(age, tmpMap);
+				}
+			});
+		});
+		// Création des statistiques
+		tmp.forEach((age, freq) -> {
+			JSONObject json = new JSONObject();
+			JSONArray value = new JSONArray();
+			for(Entry<String, List<FrequentationDTO>> entry : freq.entrySet()) {
+				value.put(entry.getValue().stream().count());
+			}
+			json.put("value", value);
+			json.put("title", age + " ans");
+			json.put("line", true);
+			stats.put(json);
+		});
+		LOGGER.info("End: Stats by age");
+		data.put("title", "Frequentation des espaces en fonction de l'age ce mois-ci");
+		data.put("labels", labels);
+		data.put("stats", stats);
+		return JsonUtils.success(data).toString();
+	}
+	
+	@GET
+	@Path("/stats/espace/week")
+	public String statsByEspaceWeek() {
+		JSONObject data = new JSONObject();
+		JSONArray stats = new JSONArray();
+		LOGGER.info("Begin: Stats by espace week");
+		// Recupération information
+		Map<String, List<FrequentationDTO>> freqs = service.getByEspaceWeek(0);
+		Map<String, List<FrequentationDTO>> freqsLast = service.getByEspaceWeek(1);
+		// Statistique mois courant + récupération clef
+		final JSONArray labels = new JSONArray();
+		final JSONArray value = new JSONArray();
+		freqs.forEach((key, val) -> {
+			labels.put(key);
+			value.put(val.stream().count());
+		});
+		JSONObject json = new JSONObject();
+		json.put("title", "Semaine courante");
+		json.put("value", value);
+		json.put("color", new JSONObject("{ \"r\": 255, \"g\": 99, \"b\": 132 }"));
+		stats.put(json);
+		// Creation statistique semaine derniere
+		final JSONArray valueLast = new JSONArray();
+		freqsLast.forEach((key, val) -> {
+			valueLast.put(val.stream().count());
+		});
+		json = new JSONObject();
+		json.put("title", "Semaine derniere");
+		json.put("value", valueLast);
+		json.put("color", new JSONObject("{ \"r\": 235, \"g\": 192, \"b\": 52 }"));
+		stats.put(json);
+		LOGGER.info("End: Stats by espace week");
+		data.put("title", "Frequentation des espace les deux dernieres semaines");
+		data.put("labels", labels);
+		data.put("stats", stats);
+		return JsonUtils.success(data).toString();
+	}
+	
+	@GET
+	@Path("/stats/espace/month")
+	public String statsByEspaceMonth() {
+		JSONObject data = new JSONObject();
+		JSONArray stats = new JSONArray();
+		LOGGER.info("Begin: Stats by espace month");
+		// Recupération information
+		Map<String, List<FrequentationDTO>> freqs = service.getByEspaceMonth(0);
+		Map<String, List<FrequentationDTO>> freqsLast = service.getByEspaceMonth(1);
+		// Statistique mois courant + récupération clef
+		final JSONArray labels = new JSONArray();
+		final JSONArray value = new JSONArray();
+		freqs.forEach((key, val) -> {
+			labels.put(key);
+			value.put(val.stream().count());
+		});
+		JSONObject json = new JSONObject();
+		json.put("title", "Mois courante");
+		json.put("value", value);
+		json.put("color", new JSONObject("{ \"r\": 255, \"g\": 99, \"b\": 132 }"));
+		stats.put(json);
+		// Creation statistique semaine derniere
+		final JSONArray valueLast = new JSONArray();
+		freqsLast.forEach((key, val) -> {
+			valueLast.put(val.stream().count());
+		});
+		json = new JSONObject();
+		json.put("title", "Mois dernier");
+		json.put("value", valueLast);
+		json.put("color", new JSONObject("{ \"r\": 235, \"g\": 192, \"b\": 52 }"));
+		stats.put(json);
+		LOGGER.info("End: Stats by espace month");
+		data.put("title", "Frequentation des espace les deux derniers mois");
+		data.put("labels", labels);
+		data.put("stats", stats);
+		return JsonUtils.success(data).toString();
+	}
+	
+}

+ 33 - 0
src/microfolie/persistance/table/FrequentationTable.java

@@ -1,10 +1,16 @@
 package microfolie.persistance.table;
 
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.List;
+import java.util.Optional;
 
+import db.Database;
 import db.DatabaseTable;
+import db.SQLQueryBuilder;
 import db.annotation.DbTable;
+import db.mapper.DatabaseMapper;
+import microfolie.persistance.entity.Espace;
 import microfolie.persistance.entity.Frequentation;
 
 @DbTable(name = "Frequentation", entity = Frequentation.class)
@@ -30,6 +36,33 @@ public class FrequentationTable extends DatabaseTable<Frequentation>{
 		return frequentation.get(0);
 	}
 	
+	public List<Frequentation> getByDate(Date from, Date to) {
+		SQLQueryBuilder sqlBuilder = SQLQueryBuilder.selectQuery("Frequentation");
+		String sql = sqlBuilder.getSQL("And DATE >= ? And DATE <= ? Order By DATE");
+		List<Object> params = sqlBuilder.getParams();
+		params.add(from);
+		params.add(to);
+		Optional<List<Frequentation>> opt = Database.query(sql, params, DatabaseMapper.listMapper(getClass().getAnnotation(DbTable.class)));
+		if (opt.isPresent()) {
+			return opt.get();
+		}
+		return new ArrayList<>();
+	}
+	
+	public List<Frequentation> getByEspaceAndDate(Espace espace, Date from, Date to) {
+		SQLQueryBuilder sqlBuilder = SQLQueryBuilder.selectQuery("Frequentation");
+		sqlBuilder.add("ESPACE", espace.id);
+		String sql = sqlBuilder.getSQL("And DATE >= ? And DATE <= ? Order By DATE");
+		List<Object> params = sqlBuilder.getParams();
+		params.add(from);
+		params.add(to);
+		Optional<List<Frequentation>> opt = Database.query(sql, params, DatabaseMapper.listMapper(getClass().getAnnotation(DbTable.class)));
+		if (opt.isPresent()) {
+			return opt.get();
+		}
+		return new ArrayList<>();
+	}
+	
 	public static FrequentationTable getInstance() {
 		if(instance == null) {
 			instance = new FrequentationTable();

+ 84 - 27
src/microfolie/service/FrequentationService.java

@@ -1,7 +1,10 @@
 package microfolie.service;
 
-import java.util.Calendar;
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 import microfolie.persistance.entity.Espace;
 import microfolie.persistance.entity.Frequentation;
@@ -9,6 +12,9 @@ import microfolie.persistance.entity.Usager;
 import microfolie.persistance.table.EspaceTable;
 import microfolie.persistance.table.FrequentationTable;
 import microfolie.persistance.table.UsagerTable;
+import microfolie.service.dto.FrequentationDTO;
+import microfolie.service.transformer.FrequentationTransformer;
+import microfolie.utils.DateUtils;
 
 public class FrequentationService {
 	
@@ -28,7 +34,7 @@ public class FrequentationService {
 		Frequentation frequentation = table.getByUsagerAndEspace(usager.id, espace.id);
 		// Ajout en base si introuvable ou si il ne date pas d'ajourd'hui
 		Date aujourdhui = new Date();
-		if (frequentation == null || compareDate(frequentation.date, aujourdhui) < 0) {
+		if (frequentation == null || DateUtils.compareDate(frequentation.date, aujourdhui) < 0) {
 			frequentation = new Frequentation();
 			frequentation.usager = usager;
 			frequentation.espace = espace;
@@ -40,31 +46,82 @@ public class FrequentationService {
 		return false;
 	}
 	
-	/**
-	 * Compare deux dates
-	 * @param date1
-	 * @param date2
-	 * @return 0 si les dates sont égales, < 0 si date1 est avant date2, > 0 si date1 est apres date2
-	 */
-	private long compareDate(Date date1, Date date2) {
-		// Transformation date1
-		Calendar cal1 = Calendar.getInstance();
-		cal1.setTime(date1);
-		cal1.set(Calendar.HOUR_OF_DAY, 0);
-		cal1.set(Calendar.MINUTE, 0);
-		cal1.set(Calendar.SECOND, 0);
-		cal1.set(Calendar.MILLISECOND, 0);
-		long time1 = cal1.getTimeInMillis();
-		// Transformation date2
-		Calendar cal2 = Calendar.getInstance();
-		cal2.setTime(date2);
-		cal2.set(Calendar.HOUR_OF_DAY, 0);
-		cal2.set(Calendar.MINUTE, 0);
-		cal2.set(Calendar.SECOND, 0);
-		cal2.set(Calendar.MILLISECOND, 0);
-		long time2 = cal2.getTimeInMillis();
-		// Comparaison
-		return time1 - time2;
+	public List<FrequentationDTO> getByWeek(int history) {
+		Date[] week = DateUtils.getDateOfTheWeek(history);
+		List<Frequentation> frequentations = table.getByDate(week[DateUtils.BEGIN_DATE], week[DateUtils.END_DATE]);
+		return FrequentationTransformer.entityToDto(frequentations);
+	}
+	
+	public Map<Date, List<FrequentationDTO>> getByDayOfWeek(int history) {
+		Map<Date, List<FrequentationDTO>> result = new LinkedHashMap<>();
+		List<FrequentationDTO> list = getByWeek(history);
+		// Creation clef map
+		for(Date d : DateUtils.getAllDateOfTheWeek(history)) {
+			result.put(d, new ArrayList<>());
+		}
+		// Remplissage map
+		list.forEach(elt -> {
+			List<FrequentationDTO> day = result.get(elt.getDate());
+			day.add(elt);
+		});
+		return result;
+	}
+	
+	public Map<String, Map<Integer, List<FrequentationDTO>>> getByAgeOnEspace(int history) {
+		List<Espace> espaces = espaceTable.getAll();
+		Date[] month = DateUtils.getDateOfTheMonth(history);
+		Map<String, Map<Integer, List<FrequentationDTO>>> result = new LinkedHashMap<>();
+		// Remplissage
+		espaces.forEach(elt -> {
+			// Création map
+			Map<Integer, List<FrequentationDTO>> map = new LinkedHashMap<>();
+			// Recup information
+			List<Frequentation> data = table.getByEspaceAndDate(elt, month[DateUtils.BEGIN_DATE], month[DateUtils.END_DATE]);
+			List<FrequentationDTO> freqs = FrequentationTransformer.entityToDto(data);
+			// Ajout
+			freqs.forEach(freq -> {
+				if (map.containsKey(freq.getAge())) {
+					List<FrequentationDTO> list = map.get(freq.getAge());
+					list.add(freq);
+				} else {
+					List<FrequentationDTO> list = new ArrayList<>();
+					list.add(freq);
+					map.put(freq.getAge(), list);
+				}
+			});
+			result.put(elt.code, map);
+		});
+		return result;
+	}
+	
+	public Map<String, List<FrequentationDTO>> getByEspaceWeek(int history) {
+		List<Espace> espaces = espaceTable.getAll();
+		Date[] week = DateUtils.getDateOfTheWeek(history);
+		Map<String, List<FrequentationDTO>> result = new LinkedHashMap<>();
+		// Remplissage
+		espaces.forEach(elt -> {
+			// Recup information
+			List<Frequentation> data = table.getByEspaceAndDate(elt, week[DateUtils.BEGIN_DATE], week[DateUtils.END_DATE]);
+			List<FrequentationDTO> freqs = FrequentationTransformer.entityToDto(data);
+			// Ajout
+			result.put(elt.code, freqs);
+		});
+		return result;
+	}
+	
+	public Map<String, List<FrequentationDTO>> getByEspaceMonth(int history) {
+		List<Espace> espaces = espaceTable.getAll();
+		Date[] month = DateUtils.getDateOfTheMonth(history);
+		Map<String, List<FrequentationDTO>> result = new LinkedHashMap<>();
+		// Remplissage
+		espaces.forEach(elt -> {
+			// Recup information
+			List<Frequentation> data = table.getByEspaceAndDate(elt, month[DateUtils.BEGIN_DATE], month[DateUtils.END_DATE]);
+			List<FrequentationDTO> freqs = FrequentationTransformer.entityToDto(data);
+			// Ajout
+			result.put(elt.code, freqs);
+		});
+		return result;
 	}
 	
 	public static FrequentationService getInstance() {

+ 0 - 1
src/microfolie/service/dto/EspaceDTO.java

@@ -10,7 +10,6 @@ public class EspaceDTO {
 	}
 	
 	public EspaceDTO(String libelle, String code) {
-		super();
 		this.libelle = libelle;
 		this.code = code;
 	}

+ 75 - 0
src/microfolie/service/dto/FrequentationDTO.java

@@ -0,0 +1,75 @@
+package microfolie.service.dto;
+
+import java.util.Date;
+
+public class FrequentationDTO {
+	
+	private String usager;
+	private String usagerCode;
+	private int age;
+	private String espace;
+	private String espaceCode;
+	private Date date;
+	
+	public FrequentationDTO() {
+		// Constructeur par defaut pour contruire un objet vide
+	}
+	
+	public FrequentationDTO(String usager, String usagerCode, int age, String espace, String espaceCode, Date date) {
+		this.usager = usager;
+		this.usagerCode = usagerCode;
+		this.age = age;
+		this.espace = espace;
+		this.espaceCode = espaceCode;
+		this.date = date;
+	}
+
+	public String getUsager() {
+		return usager;
+	}
+
+	public void setUsager(String usager) {
+		this.usager = usager;
+	}
+	
+	public String getUsagerCode() {
+		return usagerCode;
+	}
+	
+	public void setUsagerCode(String usagerCode) {
+		this.usagerCode = usagerCode;
+	}
+	
+	public int getAge() {
+		return age;
+	}
+
+	public void setAge(int age) {
+		this.age = age;
+	}
+	
+	public String getEspace() {
+		return espace;
+	}
+
+	public void setEspace(String espace) {
+		this.espace = espace;
+	}
+
+	public String getEspaceCode() {
+		return espaceCode;
+	}
+	
+	public void setEspaceCode(String espaceCode) {
+		this.espaceCode = espaceCode;
+	}
+	
+	public Date getDate() {
+		return date;
+	}
+
+	public void setDate(Date date) {
+		this.date = date;
+	}
+
+}

+ 61 - 0
src/microfolie/service/transformer/FrequentationTransformer.java

@@ -0,0 +1,61 @@
+package microfolie.service.transformer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import microfolie.persistance.entity.Espace;
+import microfolie.persistance.entity.Frequentation;
+import microfolie.persistance.entity.Usager;
+import microfolie.persistance.table.EspaceTable;
+import microfolie.persistance.table.UsagerTable;
+import microfolie.service.dto.FrequentationDTO;
+import microfolie.utils.DateUtils;
+
+public class FrequentationTransformer {
+	
+	private static UsagerTable usagerTable = UsagerTable.getInstance();
+	private static EspaceTable espaceTable = EspaceTable.getInstance();
+	
+	public static Frequentation dtoToEntity(FrequentationDTO dto) {
+		Frequentation freq = new Frequentation();
+		freq.date = dto.getDate();
+		Optional<Usager> optUsager = usagerTable.findByCode(dto.getUsagerCode());
+		Optional<Espace> optEspace = espaceTable.findByCode(dto.getEspaceCode());
+		if (optUsager.isPresent()) {
+			freq.usager = optUsager.get();
+		}
+		if (optEspace.isPresent()) {
+			freq.espace = optEspace.get();
+		}
+		return freq;
+	}
+	
+	public static List<Frequentation> dtoToEntity(List<FrequentationDTO> dto) {
+		List<Frequentation> result = new ArrayList<>();
+		dto.forEach(elt -> result.add(dtoToEntity(elt)));
+		return result;
+	}
+	
+	public static FrequentationDTO entityToDto(Frequentation freq) {
+		FrequentationDTO dto = new FrequentationDTO();
+		dto.setDate(freq.date);
+		if (freq.usager != null) {
+			dto.setUsager(freq.usager.prenom + " " + freq.usager.nom);
+			dto.setUsagerCode(freq.usager.code);
+			dto.setAge(DateUtils.getAge(freq.usager.dateNaiss));
+		}
+		if (freq.espace != null) {
+			dto.setEspace(freq.espace.libelle);
+			dto.setEspaceCode(freq.espace.code);
+		}
+		return dto;
+	}
+	
+	public static List<FrequentationDTO> entityToDto(List<Frequentation> freq) {
+		List<FrequentationDTO> result = new ArrayList<>();
+		freq.forEach(elt -> result.add(entityToDto(elt)));
+		return result;
+	}
+
+}

+ 104 - 0
src/microfolie/utils/DateUtils.java

@@ -0,0 +1,104 @@
+package microfolie.utils;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.time.ZoneId;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+
+public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
+	
+	public static final int BEGIN_DATE = 0;
+	public static final int END_DATE = 1;
+	
+	/**
+	 * Compare deux dates
+	 * @param date1
+	 * @param date2
+	 * @return 0 si les dates sont égales, < 0 si date1 est avant date2, > 0 si date1 est apres date2
+	 */
+	public static long compareDate(Date date1, Date date2) {
+		Calendar cal1 = removeTimeInformation(date1);
+		long time1 = cal1.getTimeInMillis();
+		Calendar cal2 = removeTimeInformation(date2);
+		long time2 = cal2.getTimeInMillis();
+		// Comparaison
+		return time1 - time2;
+	}
+
+	public static Date[] getDateOfTheWeek() {
+		return getDateOfTheWeek(0);
+	}
+	
+	/**
+	 * Donne la debute de debut et de fin d'une semaine
+	 * @param history Pour revenir de n semaine en arriere, 
+	 * exemple avec la valeur 1 récupère les dates de la semaine passée
+	 * @return
+	 */
+	public static Date[] getDateOfTheWeek(int history) {
+		Calendar c = GregorianCalendar.getInstance(Locale.FRANCE);
+		c = removeTimeInformation(c);
+		c.setFirstDayOfWeek(Calendar.MONDAY);
+		c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+		c.add(Calendar.DATE, -7 * history);
+		Date begin = c.getTime();
+		c.add(Calendar.DATE, 6);
+		Date end = c.getTime();
+		return new Date[]{begin, end};
+	}
+	
+	public static Date[] getAllDateOfTheWeek(int history) {
+		Calendar c = GregorianCalendar.getInstance(Locale.FRANCE);
+		c = removeTimeInformation(c);
+		c.setFirstDayOfWeek(Calendar.MONDAY);
+		c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+		c.add(Calendar.DATE, -7 * history);
+		// Récuperation date
+		Date[] result = new Date[7];
+		for(int i = 0; i < 7; i++) {
+			result[i] = c.getTime();
+			c.add(Calendar.DATE, 1);
+		}
+		return result;
+	}
+	
+	public static Date[] getDateOfTheMonth(int history) {
+		Calendar c = GregorianCalendar.getInstance(Locale.FRANCE);
+		c = removeTimeInformation(c);
+		c.setFirstDayOfWeek(Calendar.MONDAY);
+		c.set(Calendar.DAY_OF_MONTH, 1);
+		c.add(Calendar.MONTH, -1 * history);
+		Date begin = c.getTime();
+		c.add(Calendar.MONTH, 1);
+		c.add(Calendar.DATE, -1);
+		Date end = c.getTime();
+		return new Date[]{begin, end};
+	}
+	
+	public static int getAge(Date naissance) {
+		Date aujourdhui = new Date();
+		Date anniv = new Date(naissance.getTime());
+		LocalDate localAujourdhui = aujourdhui.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
+		LocalDate localNaissance = anniv.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
+		Period p = Period.between(localNaissance, localAujourdhui);
+		return p.getYears();
+	}
+	
+	private static Calendar removeTimeInformation(Date date) {
+		Calendar c = GregorianCalendar.getInstance(Locale.FRANCE);
+		c.setTime(date);
+		return removeTimeInformation(c);
+	}
+	
+	private static Calendar removeTimeInformation(Calendar c) {
+		c.set(Calendar.HOUR_OF_DAY, 0);
+		c.set(Calendar.MINUTE, 0);
+		c.set(Calendar.SECOND, 0);
+		c.set(Calendar.MILLISECOND, 0);
+		return c;
+	}
+	
+}