Admin/Sources/HeartTrack/Services/UserDataService/UserDataServiceFactice.cs

using System;
using Blazored.LocalStorage;
using HeartTrack.Models;
using HeartTrack.Services.UserDataService;
using Microsoft.AspNetCore.Components;

namespace HeartTrack.Services.UserDataServiceFactice
{
    public class UserDataServiceFactice : IUserDataService
    {
        [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 UserDataServiceFactice(HttpClient clientHttp, ILocalStorageService localStorage, NavigationManager navigationManager)
        {
            this._clientHttp = clientHttp;
            this._localStorage = localStorage;
            this._navigationManager = navigationManager;

            this.EmplacementLocalStorage = "usersData";
            this.EmplacementJson = $"{_navigationManager.BaseUri}data/fake-users.json";
        }

        public async Task AddUser(User u)
        {
            List<User> data = await getAllUsers();
            data.Add(u);
            await this.SaveAllUsers(data);
        }

        public async Task<User> getUserById(int id)
        {
            List<User> users = await getAllUsers();
            User? temp = null;

            foreach (User u in users)
            {
                if (u.Id == id)
                {
                    temp = u;
                }
            }

            return temp;
        }

        public async Task<List<User>> getAllUsers()
        {
            List<User> lUsers = new List<User>();

            lUsers = await this.getUsersFromLocalStorage();
            if (lUsers.Count == 0)
            {
                lUsers = await this.getUsersFromJson(this.EmplacementJson);
                await this.saveUsersLocalStorage(lUsers);
            }

            return lUsers;
        }

        private async Task<List<User>> getUsersFromJson(String cheminVersJson)
        {
            List<User> UsersDeserialiser = new List<User>();

            var data = await _clientHttp.GetFromJsonAsync<User[]>(cheminVersJson);
            UsersDeserialiser = data.ToList();

            return UsersDeserialiser;
        }

        private async Task<List<User>> getUsersFromLocalStorage()
        {
            List<User> UsersFromLocalStorage = null;

            var data = await _localStorage.GetItemAsync<User[]>(EmplacementLocalStorage);

            if (data == null)
            {
                UsersFromLocalStorage = new List<User>();
            }
            else
            {
                UsersFromLocalStorage = data.ToList();
            }

            return UsersFromLocalStorage;
        }

        public async Task RemoveUser(User u)
        {
            List<User> data = await getAllUsers();

            int index = -1;

            foreach (User temp in data)
            {
                if (temp.Id == u.Id)
                {
                    index = data.IndexOf(temp);
                }
            }

            if (index != -1)
            {
                data.RemoveAt(index);
            }

            await this.SaveAllUsers(data);

            data = await this.getAllUsers();
        }

        public async Task SaveAllUsers(List<User> list)
        {
            await this.saveUsersLocalStorage(list);
        }

        private async Task saveUsersLocalStorage(List<User> lUsers)
        {
            await _localStorage.SetItemAsync(this.EmplacementLocalStorage, lUsers);
        }

        public async Task UpdateUser(User u)
        {
            await this.RemoveUser(u);
            await this.AddUser(u);
        }
    }
}