add all the services

Sources/HeartTrack/HeartTrack.csproj

@@ -18,10 +18,22 @@
   <ItemGroup>
     <Folder Include="Services\ActivityDataService\" />
     <Folder Include="Models\Activity\" />
+    <Folder Include="Services\DataLocalService\" />
+    <Folder Include="Services\ReportDataService\" />
+    <Folder Include="Services\TicketLocalService\" />
+    <Folder Include="Services\UserDataService\" />
+    <Folder Include="wwwroot\data\" />
   </ItemGroup>
 
   <ItemGroup>
     <None Remove="Services\ActivityDataService\" />
     <None Remove="Models\Activity\" />
+    <None Remove="Services\DataLocalService\" />
+    <None Remove="Services\ReportDataService\" />
+    <None Remove="Services\TicketLocalService\" />
+    <None Remove="Services\UserDataService\" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Remove="wwwroot\data\" />
   </ItemGroup>
 </Project>

Sources/HeartTrack/Models/Activity/Activity.cs

@@ -18,22 +18,3 @@
         public bool HasAutoPause { get; set; }
     }
 }
-//[
-//  '{{repeat(15, 30)}}',
-//  {
-//    idActivity: '{{index(1)}}',
-//    type: '{{random("Type1", "Type2", "Type3")}}',
-//    date: '{{date(new Date(2014, 0, 1), new Date(), "YYYY-MM-dd")}}',
-//    startTime: '{{date(new Date(2014, 0, 1), new Date(), "HH:mm:ss")}}',
-//    endTime: '{{date(new Date(2014, 0, 1), new Date(), "HH:mm:ss")}}',
-//    effortRessenti: '{{integer(1, 5)}}',
-//    variability: '{{floating(1, 100)}}',
-//    variance: '{{floating(1, 100)}}',
-//    standardDeviation: '{{floating(1, 100)}}',
-//    average: '{{floating(1, 100)}}',
-//    maximum: '{{integer(80, 200)}}',
-//    minimum: '{{integer(30, 100)}}',
-//    avrTemperature: '{{floating(1, 100)}}',
-//    hasAutoPause: '{{bool()}}'
-//  }
-//]

Sources/HeartTrack/Pages/Activities.razor.cs

@@ -4,6 +4,7 @@ using Blazorise.DataGrid;
 using HeartTrack.Models;
 using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.Localization;
+using HeartTrack.Services.ActivityDataService;
 
 namespace HeartTrack.Pages
 {
@@ -14,41 +15,39 @@ namespace HeartTrack.Pages
         private int totalActivity;
 
         [Inject]
-        public HttpClient Http { get; set; }
+        private IActivityDataService ActivitiesDataService { get; set; }
 
-        [Inject]
-        public NavigationManager NavigationManager { get; set; }
-
-        [Inject]
-        public IStringLocalizer<Activities> Localizer { get; set; }
-
-        private async Task OnReadData(DataGridReadDataEventArgs<Activity> e)
-        {
-            if (e.CancellationToken.IsCancellationRequested)
+        private async Task OnReadData()
         {
-                return;
-            }
+            //if (e.CancellationToken.IsCancellationRequested)
+            //{
+            //    return;
+            //}
 
-            // When you use a real API, we use this follow code
-            //var response = await Http.GetJsonAsync<Item[]>( $"http://my-api/api/data?page={e.Page}&pageSize={e.PageSize}" );
+            //// When you use a real API, we use this follow code
+            ////var response = await Http.GetJsonAsync<Item[]>( $"http://my-api/api/data?page={e.Page}&pageSize={e.PageSize}" );
 
-            //var response = await Http.GetStringAsync("http://localhost:8080/api");
-            //var activityList = JsonConvert.DeserializeObject<List<Activity>>(response);
+            ////var response = await Http.GetStringAsync("http://localhost:8080/api");
+            ////var activityList = JsonConvert.DeserializeObject<List<Activity>>(response);
 
-            var response = (await Http.GetFromJsonAsync<Activity[]>("http://localhost:8080/api")).Skip((e.Page - 1) * e.PageSize).Take(e.PageSize).ToList();
+            //var response = (await Http.GetFromJsonAsync<Activity[]>("http://localhost:8080/api")).Skip((e.Page - 1) * e.PageSize).Take(e.PageSize).ToList();
 
-            //await Http.GetFromJsonAsync<Activity[]>("http://localhost:8080/api");
-            //Console.WriteLine(response);
+            ////await Http.GetFromJsonAsync<Activity[]>("http://localhost:8080/api");
+            ////Console.WriteLine(response);
 
-            //var response = (await Http.GetFromJsonAsync<Activity[]>($"{NavigationManager.BaseUri}fake-data-activity.json")).Skip((e.Page - 1) * e.PageSize).Take(e.PageSize).ToList();
+            ////var response = (await Http.GetFromJsonAsync<Activity[]>($"{NavigationManager.BaseUri}fake-activities.json")).Skip((e.Page - 1) * e.PageSize).Take(e.PageSize).ToList();
 
-            if (!e.CancellationToken.IsCancellationRequested)
-            {
-                totalActivity = (await Http.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api")).Count;
-                //(await Http.GetFromJsonAsync<List<Activity>>($"{NavigationManager.BaseUri}fake-data-activity.json")).Count;
-                activities = new List<Activity>(response); // an actual data for the current page
-                //Console.WriteLine(totalActivity);
-            }
+            //if (!e.CancellationToken.IsCancellationRequested)
+            //{
+            //    totalActivity = (await Http.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api")).Count;
+            //    //(await Http.GetFromJsonAsync<List<Activity>>($"{NavigationManager.BaseUri}fake-data-activity.json")).Count;
+            //    activities = new List<Activity>(response); // an actual data for the current page
+            //    //Console.WriteLine(totalActivity);
+            //}
+            //Console.WriteLine("Passage dans le OnInitializedAsync...");
+
+            this.activities = await this.ActivitiesDataService.getAllActivities();
+            this.totalActivity = activities.Count();
         }
     }
 }

Sources/HeartTrack/Program.cs

@@ -18,7 +18,10 @@ builder.Services.AddServerSideBlazor();
 
 builder.Services.AddHttpClient();
 
+// Add Services
 builder.Services.AddScoped<IDataService, DataLocalService>();
+builder.Services.AddScoped<IActivityDataService, ActivityDataServiceFactice>();
+
 
 builder.Services.AddBlazorise()
     .AddBootstrapProviders()

Sources/HeartTrack/Services/ActivityDataService/ActivityDataService.cs

@@ -1,11 +0,0 @@
-using System;
-namespace HeartTrack.Services.ActivityDataService
-{
-	public class ActivityDataService
-	{
-		public ActivityDataService()
-		{
-		}
-	}
-}
-

Sources/HeartTrack/Services/ActivityDataService/ActivityDataServiceAPI.cs

@@ -0,0 +1,84 @@
+using System;
+namespace HeartTrack.Services.ActivityDataService
+{
+	public class ActivityDataServiceAPI : IActivityDataService
+	{
+		[Inject]
+        private HttpClient _clientHttp { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp)
+        {
+            this._clientHttp = clientHttp;
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PostAsJsonAsync("http://localhost:8080/api/activities", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+			Activity activity = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities/{id}");
+			return activity;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+			List<Activity> lActivities = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities");
+            return lActivities;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.DeleteAsync($"http://localhost:8080/api/activities/{a.IdActivity}");
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync("http://localhost:8080/api/activities", list);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync($"http://localhost:8080/api/activities/{a.IdActivity}", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+	}
+}
+

Sources/HeartTrack/Services/ActivityDataService/ActivityDataServiceFactice.cs

@@ -0,0 +1,140 @@
+using System;
+using Blazored.LocalStorage;
+using HeartTrack.Models;
+using HeartTrack.Services.ActivityDataService;
+using Microsoft.AspNetCore.Components;
+
+namespace HeartTrack.Services.ActivityDataServiceFactice
+{
+    public class ActivityDataServiceFactice : IActivityDataService
+    {
+        [Inject]
+        private HttpClient _clientHttp { get; set; }
+
+        [Inject]
+        public ILocalStorageService _localStorage { get; set; }
+
+        [Inject]
+        public NavigationManager _navigationManager { get; set; }
+
+        private String EmplacementLocalStorage { get; set; }
+        private String EmplacementJson { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp, ILocalStorageService localStorage, NavigationManager navigationManager)
+        {
+            this._clientHttp = clientHttp;
+            this._localStorage = localStorage;
+            this._navigationManager = navigationManager;
+
+            this.EmplacementLocalStorage = "activitiesData";
+            this.EmplacementJson = $"{_navigationManager.BaseUri}data/fake-activities.json";
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+            data.Add(a);
+            await this.SaveAllActivities(data);
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+            Console.WriteLine("Passage dans le getFromPseudo...");
+            List<Activity> activities = await getAllActivities();
+            Activity? temp = null;
+
+            foreach (Activity a in activities)
+            {
+                if (a.IdActivity == id)
+                {
+                    temp = a;
+                }
+            }
+
+            return temp;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+            List<Activity> lActivities = new List<Activity>();
+
+            lActivities = await this.getActivitiesFromLocalStorage();
+            if(lActivities.Count == 0)
+            {
+                lActivities = await this.getActivitiesFromJson(this.EmplacementJson);
+                await this.saveActivitiesLocalStorage(lActivities);
+            }
+
+            return lActivities;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromJson(String cheminVersJson)
+        {
+            List<Activity> activitiesDeserialiser = new List<Activity>();
+
+            var data = await _clientHttp.GetFromJsonAsync<Activity[]>(cheminVersJson);
+            activitiesDeserialiser = data.ToList();
+
+            return activitiesDeserialiser;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromLocalStorage()
+        {
+            List<Activity> activitiesFromLocalStorage = null;
+
+            var data = await _localStorage.GetItemAsync<Activity[]>(EmplacementLocalStorage);
+
+            if (data == null)
+            {
+                activitiesFromLocalStorage = new List<Activity>();
+            }
+            else
+            {
+                activitiesFromLocalStorage = data.ToList();
+            }
+
+            return activitiesFromLocalStorage;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+
+            int index = -1;
+
+            foreach (Activity temp in data)
+            {
+                if (temp.IdActivity == a.IdActivity)
+                {
+                    index = data.IndexOf(temp);
+                }
+            }
+
+            if (index != -1)
+            {
+                data.RemoveAt(index);
+            }
+
+            await this.SaveAllActivities(data);
+
+            data = await this.getAllActivities();
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+            await this.saveActivitiesLocalStorage(list);
+        }
+
+        private async Task saveActivitiesLocalStorage(List<Activity> lActivities)
+        {
+            await _localStorage.SetItemAsync(this.EmplacementLocalStorage, lActivities);
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+            await this.RemoveActivity(a);
+            await this.AddActivity(a);
+        }
+    }
+}

Sources/HeartTrack/Services/ActivityDataService/IActivityDataService.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics;
 using HeartTrack.Models;
 
 namespace HeartTrack.Services.ActivityDataService
@@ -10,14 +9,13 @@ namespace HeartTrack.Services.ActivityDataService
 
         public Task SaveAllActivities(List<Activity> list);
 
-        public Task resetDataActivities();
         public Task AddActivity(Activity u);
 
         public Task RemoveActivity(Activity u);
 
         public Task UpdateActivity(Activity u);
 
-        public Task<Activity> getActivityById(String pseudo);
+        public Task<Activity> getActivityById(int id);
     }
 }
 

Sources/HeartTrack/Services/ReportDataService/IReportDataService.cs

@@ -0,0 +1,21 @@
+using System;
+using HeartTrack.Models;
+
+namespace HeartTrack.Services.ReportDataService
+{
+    public interface IReportDataService
+    {
+        public Task<List<Report>> getAllReports();
+
+        public Task SaveAllReports(List<Report> list);
+
+        public Task AddReport(Report u);
+
+        public Task RemoveReport(Report u);
+
+        public Task UpdateReport(Report u);
+
+        public Task<Report> getReportById(int id);
+    }
+}
+

Sources/HeartTrack/Services/ReportDataService/ReportDataServiceAPI.cs

@@ -0,0 +1,84 @@
+using System;
+namespace HeartTrack.Services.ActivityDataService
+{
+	public class ActivityDataServiceAPI : IActivityDataService
+	{
+		[Inject]
+        private HttpClient _clientHttp { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp)
+        {
+            this._clientHttp = clientHttp;
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PostAsJsonAsync("http://localhost:8080/api/activities", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+			Activity activity = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities/{id}");
+			return activity;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+			List<Activity> lActivities = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities");
+            return lActivities;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.DeleteAsync($"http://localhost:8080/api/activities/{a.IdActivity}");
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync("http://localhost:8080/api/activities", list);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync($"http://localhost:8080/api/activities/{a.IdActivity}", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+	}
+}
+

Sources/HeartTrack/Services/ReportDataService/ReportDataServiceFactice.cs

@@ -0,0 +1,140 @@
+using System;
+using Blazored.LocalStorage;
+using HeartTrack.Models;
+using HeartTrack.Services.ActivityDataService;
+using Microsoft.AspNetCore.Components;
+
+namespace HeartTrack.Services.ActivityDataServiceFactice
+{
+    public class ActivityDataServiceFactice : IActivityDataService
+    {
+        [Inject]
+        private HttpClient _clientHttp { get; set; }
+
+        [Inject]
+        public ILocalStorageService _localStorage { get; set; }
+
+        [Inject]
+        public NavigationManager _navigationManager { get; set; }
+
+        private String EmplacementLocalStorage { get; set; }
+        private String EmplacementJson { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp, ILocalStorageService localStorage, NavigationManager navigationManager)
+        {
+            this._clientHttp = clientHttp;
+            this._localStorage = localStorage;
+            this._navigationManager = navigationManager;
+
+            this.EmplacementLocalStorage = "activitiesData";
+            this.EmplacementJson = $"{_navigationManager.BaseUri}data/fake-activities.json";
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+            data.Add(a);
+            await this.SaveAllActivities(data);
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+            Console.WriteLine("Passage dans le getFromPseudo...");
+            List<Activity> activities = await getAllActivities();
+            Activity? temp = null;
+
+            foreach (Activity a in activities)
+            {
+                if (a.IdActivity == id)
+                {
+                    temp = a;
+                }
+            }
+
+            return temp;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+            List<Activity> lActivities = new List<Activity>();
+
+            lActivities = await this.getActivitiesFromLocalStorage();
+            if(lActivities.Count == 0)
+            {
+                lActivities = await this.getActivitiesFromJson(this.EmplacementJson);
+                await this.saveActivitiesLocalStorage(lActivities);
+            }
+
+            return lActivities;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromJson(String cheminVersJson)
+        {
+            List<Activity> activitiesDeserialiser = new List<Activity>();
+
+            var data = await _clientHttp.GetFromJsonAsync<Activity[]>(cheminVersJson);
+            activitiesDeserialiser = data.ToList();
+
+            return activitiesDeserialiser;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromLocalStorage()
+        {
+            List<Activity> activitiesFromLocalStorage = null;
+
+            var data = await _localStorage.GetItemAsync<Activity[]>(EmplacementLocalStorage);
+
+            if (data == null)
+            {
+                activitiesFromLocalStorage = new List<Activity>();
+            }
+            else
+            {
+                activitiesFromLocalStorage = data.ToList();
+            }
+
+            return activitiesFromLocalStorage;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+
+            int index = -1;
+
+            foreach (Activity temp in data)
+            {
+                if (temp.IdActivity == a.IdActivity)
+                {
+                    index = data.IndexOf(temp);
+                }
+            }
+
+            if (index != -1)
+            {
+                data.RemoveAt(index);
+            }
+
+            await this.SaveAllActivities(data);
+
+            data = await this.getAllActivities();
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+            await this.saveActivitiesLocalStorage(list);
+        }
+
+        private async Task saveActivitiesLocalStorage(List<Activity> lActivities)
+        {
+            await _localStorage.SetItemAsync(this.EmplacementLocalStorage, lActivities);
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+            await this.RemoveActivity(a);
+            await this.AddActivity(a);
+        }
+    }
+}

Sources/HeartTrack/Services/TicketLocalService/ITicketDataService.cs

@@ -0,0 +1,22 @@
+using System;
+using HeartTrack.Models;
+
+namespace HeartTrack.Services.ActivityDataService
+{
+    public interface IActivityDataService
+    {
+        public Task<List<Activity>> getAllActivities();
+
+        public Task SaveAllActivities(List<Activity> list);
+
+        public Task ResetDataActivities();
+        public Task AddActivity(Activity u);
+
+        public Task RemoveActivity(Activity u);
+
+        public Task UpdateActivity(Activity u);
+
+        public Task<Activity> getActivityById(int id);
+    }
+}
+

Sources/HeartTrack/Services/TicketLocalService/TicketDataServiceAPI.cs

@@ -0,0 +1,84 @@
+using System;
+namespace HeartTrack.Services.ActivityDataService
+{
+	public class ActivityDataServiceAPI : IActivityDataService
+	{
+		[Inject]
+        private HttpClient _clientHttp { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp)
+        {
+            this._clientHttp = clientHttp;
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PostAsJsonAsync("http://localhost:8080/api/activities", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+			Activity activity = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities/{id}");
+			return activity;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+			List<Activity> lActivities = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities");
+            return lActivities;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.DeleteAsync($"http://localhost:8080/api/activities/{a.IdActivity}");
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync("http://localhost:8080/api/activities", list);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync($"http://localhost:8080/api/activities/{a.IdActivity}", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+	}
+}
+

Sources/HeartTrack/Services/TicketLocalService/TicketDataServiceFactice.cs

@@ -0,0 +1,140 @@
+using System;
+using Blazored.LocalStorage;
+using HeartTrack.Models;
+using HeartTrack.Services.ActivityDataService;
+using Microsoft.AspNetCore.Components;
+
+namespace HeartTrack.Services.ActivityDataServiceFactice
+{
+    public class ActivityDataServiceFactice : IActivityDataService
+    {
+        [Inject]
+        private HttpClient _clientHttp { get; set; }
+
+        [Inject]
+        public ILocalStorageService _localStorage { get; set; }
+
+        [Inject]
+        public NavigationManager _navigationManager { get; set; }
+
+        private String EmplacementLocalStorage { get; set; }
+        private String EmplacementJson { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp, ILocalStorageService localStorage, NavigationManager navigationManager)
+        {
+            this._clientHttp = clientHttp;
+            this._localStorage = localStorage;
+            this._navigationManager = navigationManager;
+
+            this.EmplacementLocalStorage = "activitiesData";
+            this.EmplacementJson = $"{_navigationManager.BaseUri}data/fake-activities.json";
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+            data.Add(a);
+            await this.SaveAllActivities(data);
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+            Console.WriteLine("Passage dans le getFromPseudo...");
+            List<Activity> activities = await getAllActivities();
+            Activity? temp = null;
+
+            foreach (Activity a in activities)
+            {
+                if (a.IdActivity == id)
+                {
+                    temp = a;
+                }
+            }
+
+            return temp;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+            List<Activity> lActivities = new List<Activity>();
+
+            lActivities = await this.getActivitiesFromLocalStorage();
+            if(lActivities.Count == 0)
+            {
+                lActivities = await this.getActivitiesFromJson(this.EmplacementJson);
+                await this.saveActivitiesLocalStorage(lActivities);
+            }
+
+            return lActivities;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromJson(String cheminVersJson)
+        {
+            List<Activity> activitiesDeserialiser = new List<Activity>();
+
+            var data = await _clientHttp.GetFromJsonAsync<Activity[]>(cheminVersJson);
+            activitiesDeserialiser = data.ToList();
+
+            return activitiesDeserialiser;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromLocalStorage()
+        {
+            List<Activity> activitiesFromLocalStorage = null;
+
+            var data = await _localStorage.GetItemAsync<Activity[]>(EmplacementLocalStorage);
+
+            if (data == null)
+            {
+                activitiesFromLocalStorage = new List<Activity>();
+            }
+            else
+            {
+                activitiesFromLocalStorage = data.ToList();
+            }
+
+            return activitiesFromLocalStorage;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+
+            int index = -1;
+
+            foreach (Activity temp in data)
+            {
+                if (temp.IdActivity == a.IdActivity)
+                {
+                    index = data.IndexOf(temp);
+                }
+            }
+
+            if (index != -1)
+            {
+                data.RemoveAt(index);
+            }
+
+            await this.SaveAllActivities(data);
+
+            data = await this.getAllActivities();
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+            await this.saveActivitiesLocalStorage(list);
+        }
+
+        private async Task saveActivitiesLocalStorage(List<Activity> lActivities)
+        {
+            await _localStorage.SetItemAsync(this.EmplacementLocalStorage, lActivities);
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+            await this.RemoveActivity(a);
+            await this.AddActivity(a);
+        }
+    }
+}

Sources/HeartTrack/Services/UserDataService/IUserDataService.cs

@@ -0,0 +1,22 @@
+using System;
+using HeartTrack.Models;
+
+namespace HeartTrack.Services.ActivityDataService
+{
+    public interface IActivityDataService
+    {
+        public Task<List<Activity>> getAllActivities();
+
+        public Task SaveAllActivities(List<Activity> list);
+
+        public Task ResetDataActivities();
+        public Task AddActivity(Activity u);
+
+        public Task RemoveActivity(Activity u);
+
+        public Task UpdateActivity(Activity u);
+
+        public Task<Activity> getActivityById(int id);
+    }
+}
+

Sources/HeartTrack/Services/UserDataService/UserDataServiceAPI.cs

@@ -0,0 +1,84 @@
+using System;
+namespace HeartTrack.Services.ActivityDataService
+{
+	public class ActivityDataServiceAPI : IActivityDataService
+	{
+		[Inject]
+        private HttpClient _clientHttp { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp)
+        {
+            this._clientHttp = clientHttp;
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PostAsJsonAsync("http://localhost:8080/api/activities", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+			Activity activity = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities/{id}");
+			return activity;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+			List<Activity> lActivities = await _clientHttp.GetFromJsonAsync<List<Activity>>("http://localhost:8080/api/activities");
+            return lActivities;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.DeleteAsync($"http://localhost:8080/api/activities/{a.IdActivity}");
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync("http://localhost:8080/api/activities", list);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+			HttpResponseMessage response = await _clientHttp.PutAsJsonAsync($"http://localhost:8080/api/activities/{a.IdActivity}", a);
+
+			if (response.IsSuccessStatusCode)
+			{
+				// La requête a réussi
+			}
+			else
+			{
+				// La requête a échoué
+			}
+        }
+	}
+}
+

Sources/HeartTrack/Services/UserDataService/UserDataServiceFactice.cs

@@ -0,0 +1,140 @@
+using System;
+using Blazored.LocalStorage;
+using HeartTrack.Models;
+using HeartTrack.Services.ActivityDataService;
+using Microsoft.AspNetCore.Components;
+
+namespace HeartTrack.Services.ActivityDataServiceFactice
+{
+    public class ActivityDataServiceFactice : IActivityDataService
+    {
+        [Inject]
+        private HttpClient _clientHttp { get; set; }
+
+        [Inject]
+        public ILocalStorageService _localStorage { get; set; }
+
+        [Inject]
+        public NavigationManager _navigationManager { get; set; }
+
+        private String EmplacementLocalStorage { get; set; }
+        private String EmplacementJson { get; set; }
+
+
+        public ActivityDataServiceFactice(HttpClient clientHttp, ILocalStorageService localStorage, NavigationManager navigationManager)
+        {
+            this._clientHttp = clientHttp;
+            this._localStorage = localStorage;
+            this._navigationManager = navigationManager;
+
+            this.EmplacementLocalStorage = "activitiesData";
+            this.EmplacementJson = $"{_navigationManager.BaseUri}data/fake-activities.json";
+        }
+
+        public async Task AddActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+            data.Add(a);
+            await this.SaveAllActivities(data);
+        }
+
+        public async Task<Activity> getActivityById(int id)
+        {
+            Console.WriteLine("Passage dans le getFromPseudo...");
+            List<Activity> activities = await getAllActivities();
+            Activity? temp = null;
+
+            foreach (Activity a in activities)
+            {
+                if (a.IdActivity == id)
+                {
+                    temp = a;
+                }
+            }
+
+            return temp;
+        }
+
+        public async Task<List<Activity>> getAllActivities()
+        {
+            List<Activity> lActivities = new List<Activity>();
+
+            lActivities = await this.getActivitiesFromLocalStorage();
+            if(lActivities.Count == 0)
+            {
+                lActivities = await this.getActivitiesFromJson(this.EmplacementJson);
+                await this.saveActivitiesLocalStorage(lActivities);
+            }
+
+            return lActivities;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromJson(String cheminVersJson)
+        {
+            List<Activity> activitiesDeserialiser = new List<Activity>();
+
+            var data = await _clientHttp.GetFromJsonAsync<Activity[]>(cheminVersJson);
+            activitiesDeserialiser = data.ToList();
+
+            return activitiesDeserialiser;
+        }
+
+        private async Task<List<Activity>> getActivitiesFromLocalStorage()
+        {
+            List<Activity> activitiesFromLocalStorage = null;
+
+            var data = await _localStorage.GetItemAsync<Activity[]>(EmplacementLocalStorage);
+
+            if (data == null)
+            {
+                activitiesFromLocalStorage = new List<Activity>();
+            }
+            else
+            {
+                activitiesFromLocalStorage = data.ToList();
+            }
+
+            return activitiesFromLocalStorage;
+        }
+
+        public async Task RemoveActivity(Activity a)
+        {
+            List<Activity> data = await getAllActivities();
+
+            int index = -1;
+
+            foreach (Activity temp in data)
+            {
+                if (temp.IdActivity == a.IdActivity)
+                {
+                    index = data.IndexOf(temp);
+                }
+            }
+
+            if (index != -1)
+            {
+                data.RemoveAt(index);
+            }
+
+            await this.SaveAllActivities(data);
+
+            data = await this.getAllActivities();
+        }
+
+        public async Task SaveAllActivities(List<Activity> list)
+        {
+            await this.saveActivitiesLocalStorage(list);
+        }
+
+        private async Task saveActivitiesLocalStorage(List<Activity> lActivities)
+        {
+            await _localStorage.SetItemAsync(this.EmplacementLocalStorage, lActivities);
+        }
+
+        public async Task UpdateActivity(Activity a)
+        {
+            await this.RemoveActivity(a);
+            await this.AddActivity(a);
+        }
+    }
+}