Adam
/
TourIAm
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

implement UserDataServiceClientBase;

This commit is contained in:
Loretta 2024-08-26 20:10:09 +02:00
parent 87240cb77d
commit 76b6c15746
8 changed files with 445 additions and 814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TIAMMobileApp/Services/ComponentUpdateServiceWeb.cs
View File

@ -1,4 +1,6 @@
using TIAMWebApp.Shared.Application.Interfaces; using TIAMWebApp.Shared.Application.Interfaces;
using TIAMWebApp.Shared.Application.Services;
namespace TIAMMobileApp.Services namespace TIAMMobileApp.Services
{ {
public class ComponentUpdateServiceMobile : ComponentUpdateServiceBase public class ComponentUpdateServiceMobile : ComponentUpdateServiceBase

388
TIAMMobileApp/Services/UserDataServiceMobile.cs
View File

@ -17,391 +17,7 @@ using TIAMWebApp.Shared.Application.Utility;
namespace TIAMMobileApp.Services namespace TIAMMobileApp.Services
{ {
public class UserDataServiceMobile : IUserDataService public class UserDataServiceMobile(HttpClient http, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
{ : UserDataServiceClientBase(http, sessionService, secureStorageHandler, serviceProviderDataService, logWriters);
private readonly HttpClient _http;
private readonly ISessionService _sessionService;
private readonly ISecureStorageHandler _secureStorageHandler;
private readonly IServiceProviderDataService _serviceProviderDataService;
private readonly LoggerClient<UserDataServiceMobile> _logger;
public UserDataServiceMobile(HttpClient http, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
{
_http = http;
_sessionService = sessionService;
_secureStorageHandler = secureStorageHandler;
//this._browserConsoleLogWriter = new BrowserConsoleLogWriter(jsRuntime);
_serviceProviderDataService = serviceProviderDataService;
_logger = new LoggerClient<UserDataServiceMobile>(logWriters.ToArray());
//_logger = new TIAM.Core.Loggers.Logger<UserDataServiceWeb>(AppType.Web, LogLevel.Info, logWriters.ToArray());
//_logger = new TIAM.Core.Loggers.Logger<UserDataServiceWeb>(AppType.Web, LogLevel.Info, logWriter);
}
public async Task<UserSessionModel> IsLoggedInAsync(Guid id)
{
//api call to get user
var userModelDto = await GetUserDetailByIdAsync(id);
if (userModelDto != null)
{
var userProperties = new Dictionary<Guid, string>();
//get user's properties
var hasProperties = userModelDto.ServiceProviders.Count > 0 ? true : userModelDto.ServiceProviders.Count == 0 ? false : false;
if (hasProperties)
{
//var Properties = await serviceProviderDataService.GetPropertiesByOwnerIdAsync(userModelDto.Id);
var Properties = userModelDto.ServiceProviders;
_logger.Info($"{Properties.Count} properties found");
foreach (var property in Properties)
{
userProperties.Add(property.Id, property.Name);
}
}
//create user session model
var user = new UserSessionModel(userModelDto.Id, UserType.User, userModelDto, userProperties, 1);
return user;
}
else
{
return null;
}
}
public async Task<string> TestUserApi(int Param)
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.UserTest}";
var response = await _http.PostAsJsonAsync(url, Param);
var result = await response.Content.ReadAsStringAsync();
return result;
}
public async Task<string> AuthenticateUser(LoginModel loginModel)
{
var result = string.Empty;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.AuthenticateUser}";
var response = await _http.PostAsJsonAsync(url, loginModel);
//try
//{
// Logger.Detail("Login started: " + "Email: " + loginModel.Email + ", Password: " + loginModel.Password);
//}
//catch (Exception ex)
//{
// _logger.Error(ex.Message, ex);
//}
if (response.IsSuccessStatusCode)
{
result = await response.Content.ReadAsStringAsync();
}
else
{
result = await response.Content.ReadAsStringAsync();
}
//result = await response.Content.ReadAsStringAsync();
return result;
}
public async Task<(bool isSuccess, string ErrorMessage)> CreateUser(RegistrationModel regModel)
{
var isSuccess = true;
var result = string.Empty;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateUser}";
_logger.Info("CreateUser url: " + url);
var response = await _http.PostAsJsonAsync(url, regModel);
result = await response.Content.ReadAsStringAsync();
/*if (response.IsSuccessStatusCode)
{
isSuccess = true;
result = await response.Content.ReadAsStringAsync();
}
else
{
isSuccess = false;
result = await response.Content.ReadAsStringAsync();
}*/
return (isSuccess, result);
}
public async Task<(bool isSuccess, UserModelDto? user)> CreateGuestUser(RegistrationModel regModel)
{
var isSuccess = false;
var result = string.Empty;
var user = new UserModelDto();
var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateGuestUser}";
_logger.Info("CreateGuestUser url: " + url);
var response = await _http.PostAsJsonAsync(url, regModel);
if (response.IsSuccessStatusCode)
{
isSuccess = true;
result = await response.Content.ReadAsStringAsync();
_logger.Info("CreateGuestUser result: " + result);
user = JsonConvert.DeserializeObject<UserModelDto>(result);
}
else
{
isSuccess = false;
result = await response.Content.ReadAsStringAsync();
user = null;
}
return (isSuccess, user);
}
public async Task<List<UserModelDto>?> GetUsersAsync()
{
return await _http.GetFromJsonAsync<List<UserModelDto>>(APIUrls.GetUsers);
}
public async Task<List<UserModelDtoDetail>?> GetUsersWithDetailsAsync()
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUsersWithDetails}";
_logger.Info("GetUserByEmailAsync url: " + url + "!");
var response = await _http.GetFromJsonAsync<List<UserModelDtoDetail>>(APIUrls.GetUsersWithDetails);
//var result = await response.Content.ReadAsStringAsync();
//var user = JsonConvert.DeserializeObject<UserModelDto>(result);
return response;
}
public async Task<UserModelDto?> GetUserByEmailAsync(string email)
{
try
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserByEmail}/{email}";
_logger.Info("GetUserByEmailAsync url: " + url + ", " + email);
var response = await _http.GetAsync(url);
response.EnsureSuccessStatusCode();
if (response.Content != null)
{
var jsonResponse = await response.Content.ReadAsStringAsync();
var user = System.Text.Json.JsonSerializer.Deserialize<UserModelDto>(jsonResponse, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
return user;
}
else
{
return null;
}
}
catch (HttpRequestException httpRequestException)
{
// Handle specific HTTP request exceptions
_logger.DebugConditional($"Request error: {httpRequestException.Message}");
throw;
}
catch (Exception ex)
{
// Handle other possible exceptions
_logger.DebugConditional($"An error occurred: {ex.Message}");
throw;
}
}
public async Task<UserModelDto?> GetUserByIdAsync(Guid id)
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserById}";
_logger.Info("GetUserByIdAsync url: " + url + ", " + id.ToString());
var response = await _http.PostAsJsonAsync(url, id);
var result = await response.Content.ReadAsStringAsync();
var user = JsonConvert.DeserializeObject<UserModelDto>(result);
return user;
}
public async Task<UserModelDtoDetail?> GetUserDetailByIdAsync(Guid id)
{
_logger.Info("GetUserDetailByIdAsync", "GLOBAL_LOGGER");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserDetailById}";
_logger.Info("GetUserDetailByIdAsync url: " + url + ", " + id.ToString());
var response = await _http.PostAsJsonAsync(url, id);
var result = await response.Content.ReadAsStringAsync();
var user = JsonConvert.DeserializeObject<UserModelDtoDetail>(result);
return user;
}
public async Task<bool> RefreshToken()
{
_logger.Info("RefreshToken() called");
var isTokenRefreshed = false;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.RefreshToken}";
//var url = APIUrls.RefreshToken;
var serializedStr = JsonConvert.SerializeObject(new AuthenticateRequestAndResponse
{
RefreshToken = Setting.UserBasicDetails.RefreshToken,
AccessToken = Setting.UserBasicDetails.AccessToken
});
try
{
_logger.Info("Refreshtoken url: " + url);
var response = await _http.PostAsync(url, new StringContent(serializedStr, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
var contentStr = await response.Content.ReadAsStringAsync();
var mainResponse = JsonConvert.DeserializeObject<MainResponse>(contentStr);
if (mainResponse.IsSuccess)
{
var tokenDetails = JsonConvert.DeserializeObject<AuthenticateRequestAndResponse>(mainResponse.Content.ToString());
Setting.UserBasicDetails.AccessToken = tokenDetails.AccessToken;
Setting.UserBasicDetails.RefreshToken = tokenDetails.RefreshToken;
var userDetailsStr = JsonConvert.SerializeObject(Setting.UserBasicDetails);
await _secureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userDetailsStr);
isTokenRefreshed = true;
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error("Refreshtoken exception: " + ex.Message, ex);
}
return isTokenRefreshed;
}
public async Task<bool> Logout(string? refreshToken)
{
_logger.Info($"Logout called; refreshToken: {refreshToken}");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.LogoutUser}";
var result = false;
var response = await _http.PostAsJsonAsync(url, refreshToken);
if (response.IsSuccessStatusCode)
{
var resultMessage = await response.Content.ReadAsStringAsync();
_logger.Detail($"Logout response: {resultMessage}");
if (resultMessage == "OK")
{
result = true;
}
else
{
result = false;
}
}
else
{
result = false;
}
_logger.Detail($"Logout: {result}");
return result;
}
public async Task<bool> SendForgottenPasswordMail(string emailAddress)
{
_logger.Info("SendForgottenPasswordMail() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendForgottenPasswordMail}";
var response = await _http.PostAsJsonAsync(url, emailAddress);
var success = await response.Content.ReadFromJsonAsync<bool>();
_logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
return success;
}
public async Task<string> ValidateForgotPasswordToken(Guid userId, string token)
{
var result = "";
_logger.Info("ValidateForgotPasswordToken() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.ValidateForgottenPasswordToken}";
var parameters = new[] { userId.ToString(), token };
var response = await _http.PostAsJsonAsync(url, parameters);
result = await response.Content.ReadAsStringAsync();
_logger.Detail($"ValidateForgotPasswordToken(): {result}");
return result;
}
public async Task<bool> SetEmailConfirmed(Guid userId)
{
var result = false;
_logger.Info("SetEmailConfirmed() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SetEmailConfirmed}";
var response = await _http.PostAsJsonAsync(url, userId);
result = await response.Content.ReadFromJsonAsync<bool>();
_logger.Detail($"ValidateForgotPasswordToken(): {result.ToString()}");
return result;
}
public async Task<bool> SendWelcomeMail(string emailAddress)
{
_logger.Info("SendWelcomeMail() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendWelcomeMail}";
var response = await _http.PostAsJsonAsync(url, emailAddress);
var success = await response.Content.ReadFromJsonAsync<bool>();
_logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
return success;
}
//public Task<Dictionary<int, string>> GetUserRolesAsync(UserModel userModel)
//{
// //TODO Finish this
// //get the userModel's roles
// var role = userModel.UserRoles;
// foreach (var roleType in roleTypes)
// {
// if ((role & roleType.Id) == roleType.Id)
// {
// //add the role to the dictionary
// userRoleTypes.Add(roleType.Id, roleType.RoleName);
// }
// }
// return Task.FromResult(userRoleTypes);
//}
}
} }

2
TIAMWebApp/Client/Services/ComponentUpdateServiceWeb.cs
View File

@ -1,4 +1,6 @@
using TIAMWebApp.Shared.Application.Interfaces; using TIAMWebApp.Shared.Application.Interfaces;
using TIAMWebApp.Shared.Application.Services;
namespace TIAMWebApp.Client.Services namespace TIAMWebApp.Client.Services
{ {
public class ComponentUpdateServiceWeb : ComponentUpdateServiceBase public class ComponentUpdateServiceWeb : ComponentUpdateServiceBase

395
TIAMWebApp/Client/Services/UserDataServiceWeb.cs
View File

@ -14,401 +14,12 @@ using AyCode.Core.Extensions;
using System.Text.Json; using System.Text.Json;
using TIAM.Models; using TIAM.Models;
using AyCode.Blazor.Components.Services; using AyCode.Blazor.Components.Services;
using TIAMWebApp.Shared.Application.Services;
namespace TIAMWebApp.Client.Services namespace TIAMWebApp.Client.Services
{ {
public class UserDataServiceWeb : IUserDataService public class UserDataServiceWeb(HttpClient http, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
{ : UserDataServiceClientBase(http, sessionService, secureStorageHandler, serviceProviderDataService, logWriters);
private readonly HttpClient _http;
private readonly ISessionService _sessionService;
private readonly ISecureStorageHandler _secureStorageHandler;
//private readonly BrowserConsoleLogWriter _browserConsoleLogWriter;
private readonly IServiceProviderDataService _serviceProviderDataService;
private readonly LoggerClient<UserDataServiceWeb> _logger;
public UserDataServiceWeb(HttpClient http, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
//public UserDataServiceWeb(HttpClient http, ISecureStorageHandler secureStorageHandler, IJSRuntime jSRuntime, IServiceProviderDataService serviceProviderDataService, HttpClientLogItemWriter logWriter)
{
_http = http;
_sessionService = sessionService;
_secureStorageHandler = secureStorageHandler;
//this._browserConsoleLogWriter = new BrowserConsoleLogWriter(jsRuntime);
_serviceProviderDataService = serviceProviderDataService;
_logger = new LoggerClient<UserDataServiceWeb>(logWriters.ToArray());
//_logger = new TIAM.Core.Loggers.Logger<UserDataServiceWeb>(AppType.Web, LogLevel.Info, logWriters.ToArray());
//_logger = new TIAM.Core.Loggers.Logger<UserDataServiceWeb>(AppType.Web, LogLevel.Info, logWriter);
}
public async Task<UserSessionModel> IsLoggedInAsync(Guid id)
{
//api call to get user
var userModelDto = await GetUserDetailByIdAsync(id);
if (userModelDto != null)
{
var userProperties = new Dictionary<Guid, string>();
//get user's properties
var hasProperties = userModelDto.ServiceProviders.Count > 0 ? true : (userModelDto.ServiceProviders.Count == 0 ? false : false);
if (hasProperties)
{
//var Properties = await serviceProviderDataService.GetPropertiesByOwnerIdAsync(userModelDto.Id);
var properties = userModelDto.ServiceProviders;
_logger.Info($"{properties.Count} properties found");
foreach (var property in properties)
{
userProperties.Add(property.Id, property.Name);
}
}
//create user session model
var user = new UserSessionModel(userModelDto.Id, UserType.User, userModelDto, userProperties, 1);
return user;
}
else
{
return null;
}
}
public async Task<string> TestUserApi(int Param)
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.UserTest}";
var response = await _http.PostAsJsonAsync(url, Param);
var result = await response.Content.ReadAsStringAsync();
return result;
}
public async Task<string> AuthenticateUser(LoginModel loginModel)
{
var result = string.Empty;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.AuthenticateUser}";
var response = await _http.PostAsJsonAsync(url, loginModel);
//try
//{
// Logger.Detail("Login started: " + "Email: " + loginModel.Email + ", Password: " + loginModel.Password);
//}
//catch (Exception ex)
//{
// _logger.Error(ex.Message, ex);
//}
if (response.IsSuccessStatusCode)
{
result = await response.Content.ReadAsStringAsync();
}
else
{
result = await response.Content.ReadAsStringAsync();
}
//result = await response.Content.ReadAsStringAsync();
return result;
}
public async Task<(bool isSuccess, string ErrorMessage)> CreateUser(RegistrationModel regModel)
{
var isSuccess = true;
var result = string.Empty;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateUser}";
_logger.Info("CreateUser url: " + url);
var response = await _http.PostAsJsonAsync(url, regModel);
result = await response.Content.ReadAsStringAsync();
/*if (response.IsSuccessStatusCode)
{
isSuccess = true;
result = await response.Content.ReadAsStringAsync();
}
else
{
isSuccess = false;
result = await response.Content.ReadAsStringAsync();
}*/
return (isSuccess, result);
}
public async Task<(bool isSuccess, UserModelDto? user)> CreateGuestUser(RegistrationModel regModel)
{
var isSuccess = false;
var result = string.Empty;
var user = new UserModelDto();
var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateGuestUser}";
_logger.Info("CreateGuestUser url: " + url);
var response = await _http.PostAsJsonAsync(url, regModel);
if (response.IsSuccessStatusCode)
{
isSuccess = true;
result = await response.Content.ReadAsStringAsync();
_logger.Info("CreateGuestUser result: " + result);
user = JsonConvert.DeserializeObject<UserModelDto>(result);
}
else
{
isSuccess = false;
result = await response.Content.ReadAsStringAsync();
user = null;
}
return (isSuccess, user);
}
public async Task<List<UserModelDto>?> GetUsersAsync()
{
return await _http.GetFromJsonAsync<List<UserModelDto>>(APIUrls.GetUsers);
}
public async Task<List<UserModelDtoDetail>> GetUsersWithDetailsAsync()
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUsersWithDetails}";
_logger.Info("GetUserByEmailAsync url: " + url + "!");
var response = await _http.GetFromJsonAsync<List<UserModelDtoDetail>>(APIUrls.GetUsersWithDetails);
//var result = await response.Content.ReadAsStringAsync();
//var user = JsonConvert.DeserializeObject<UserModelDto>(result);
return response ?? [];
}
public async Task<UserModelDto?> GetUserByEmailAsync(string email)
{
try
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserByEmail}/{email}";
_logger.Info("GetUserByEmailAsync url: " + url + ", " + email);
var response = await _http.GetAsync(url);
response.EnsureSuccessStatusCode();
if (response.Content != null)
{
var jsonResponse = await response.Content.ReadAsStringAsync();
var user = System.Text.Json.JsonSerializer.Deserialize<UserModelDto>(jsonResponse, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
return user;
}
else
{
return null;
}
}
catch (HttpRequestException httpRequestException)
{
// Handle specific HTTP request exceptions
_logger.DebugConditional($"Request error: {httpRequestException.Message}");
throw;
}
catch (Exception ex)
{
// Handle other possible exceptions
_logger.DebugConditional($"An error occurred: {ex.Message}");
throw;
}
}
public async Task<UserModelDto?> GetUserByIdAsync(Guid id)
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserById}";
_logger.Info("GetUserByIdAsync url: " + url + ", " + id.ToString());
var response = await _http.PostAsJsonAsync(url, id);
var result = await response.Content.ReadAsStringAsync();
var user = JsonConvert.DeserializeObject<UserModelDto>(result);
return user;
}
public async Task<UserModelDtoDetail?> GetUserDetailByIdAsync(Guid id)
{
_logger.Info("GetUserDetailByIdAsync", "GLOBAL_LOGGER");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserDetailById}";
_logger.Info("GetUserDetailByIdAsync url: " + url + ", " + id.ToString());
var response = await _http.PostAsJsonAsync(url, id);
//var result = await response.Content.ReadAsStringAsync();
var result = await response.Content.ReadFromJsonAsync<UserModelDtoDetail>();
//var user = JsonConvert.DeserializeObject<UserModelDtoDetail>(result);
return result;
}
public async Task<bool> RefreshToken()
{
_logger.Info("RefreshToken() called");
var isTokenRefreshed = false;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.RefreshToken}";
//var url = APIUrls.RefreshToken;
var serializedStr = JsonConvert.SerializeObject(new AuthenticateRequestAndResponse
{
RefreshToken = Setting.UserBasicDetails.RefreshToken,
AccessToken = Setting.UserBasicDetails.AccessToken
});
try
{
_logger.Info("Refreshtoken url: " + url);
var response = await _http.PostAsync(url, new StringContent(serializedStr, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
var contentStr = await response.Content.ReadAsStringAsync();
var mainResponse = JsonConvert.DeserializeObject<MainResponse>(contentStr);
if (mainResponse.IsSuccess)
{
var tokenDetails = JsonConvert.DeserializeObject<AuthenticateRequestAndResponse>(mainResponse.Content.ToString());
Setting.UserBasicDetails.AccessToken = tokenDetails.AccessToken;
Setting.UserBasicDetails.RefreshToken = tokenDetails.RefreshToken;
var userDetailsStr = JsonConvert.SerializeObject(Setting.UserBasicDetails);
await _secureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userDetailsStr);
isTokenRefreshed = true;
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error("Refreshtoken exception: " + ex.Message, ex);
}
return isTokenRefreshed;
}
public async Task<bool> Logout(string? refreshToken)
{
_logger.Info($"Logout called; refreshToken: {refreshToken}");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.LogoutUser}";
var result = false;
var response = await _http.PostAsJsonAsync(url, refreshToken);
if (response.IsSuccessStatusCode)
{
var resultMessage = await response.Content.ReadAsStringAsync();
_logger.Detail($"Logout response: {resultMessage}");
if (resultMessage == "OK")
{
result = true;
}
else
{
result = false;
}
}
else
{
result = false;
}
_logger.Detail($"Logout: {result}");
return result;
}
public async Task<bool> SendForgottenPasswordMail(string emailAddress)
{
_logger.Info("SendForgottenPasswordMail() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendForgottenPasswordMail}";
var response = await _http.PostAsJsonAsync(url, emailAddress);
var success = await response.Content.ReadFromJsonAsync<bool>();
_logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
return success;
}
public async Task<string> ValidateForgotPasswordToken(Guid userId, string token)
{
var result = "";
_logger.Info("ValidateForgotPasswordToken() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.ValidateForgottenPasswordToken}";
var parameters = new[] { userId.ToString(), token };
var response = await _http.PostAsJsonAsync(url, parameters);
result = await response.Content.ReadAsStringAsync();
_logger.Detail($"ValidateForgotPasswordToken(): {result}");
return result;
}
public async Task<bool> SetEmailConfirmed(Guid userId)
{
var result = false;
_logger.Info("SetEmailConfirmed() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SetEmailConfirmed}";
var response = await _http.PostAsJsonAsync(url, userId);
result = await response.Content.ReadFromJsonAsync<bool>();
_logger.Detail($"ValidateForgotPasswordToken(): {result.ToString()}");
return result;
}
public async Task<bool> SendWelcomeMail(string emailAddress)
{
_logger.Info("SendWelcomeMail() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendWelcomeMail}";
var response = await _http.PostAsJsonAsync(url, emailAddress);
var success = await response.Content.ReadFromJsonAsync<bool>();
_logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
return success;
}
/*public Task<Dictionary<int, string>> GetUserRolesAsync(UserModel userModel)
{
//TODO: finish this
//get the userModel's roles
int role = userModel.UserRoles;
foreach (var roleType in roleTypes)
{
if ((role & roleType.Id) == roleType.Id)
{
//add the role to the dictionary
userRoleTypes.Add(roleType.Id, roleType.RoleName);
}
}
return Task.FromResult(userRoleTypes);
}*/
}
} }

31
TIAMWebApp/Shared/Interfaces/IComponentUpdateService.cs
View File

@ -2,37 +2,6 @@
namespace TIAMWebApp.Shared.Application.Interfaces namespace TIAMWebApp.Shared.Application.Interfaces
{ {
public abstract class ComponentUpdateServiceBase : IComponentUpdateService
{
protected Dictionary<Type, IComponentUpdateItem> ComponentsByType = [];
public virtual void CallRequestRefreshAll()
{
foreach (var component in ComponentsByType.Values)
component.CallRequestRefresh();
}
public void CallRequestRefresh<T>() where T : class, IComponent
{
if (ComponentsByType.TryGetValue(typeof(T), out var componentUpdateItem))
componentUpdateItem.CallRequestRefresh();
}
public IComponentUpdateItem GetOrAddComponent<T>() where T : class, IComponent
{
var componentType = typeof(T);
if (ComponentsByType.TryGetValue(componentType, out var componentUpdateItem))
return componentUpdateItem;
componentUpdateItem = new ComponentUpdateItem();
ComponentsByType.Add(componentType, componentUpdateItem);
return componentUpdateItem;
}
}
public class ComponentUpdateItem : IComponentUpdateItem public class ComponentUpdateItem : IComponentUpdateItem
{ {
public event Action? RefreshRequested; public event Action? RefreshRequested;

5
TIAMWebApp/Shared/Interfaces/IUserDataService.cs
View File

@ -4,11 +4,6 @@ using TIAMWebApp.Shared.Application.Models.PageModels;
namespace TIAMWebApp.Shared.Application.Interfaces namespace TIAMWebApp.Shared.Application.Interfaces
{ {
public abstract class UserDataService : IUserDataService
{
}
public interface IUserDataService public interface IUserDataService
{ {
public Task<UserSessionModel> IsLoggedInAsync(Guid id); public Task<UserSessionModel> IsLoggedInAsync(Guid id);

35
TIAMWebApp/Shared/Services/ComponentUpdateServiceBase.cs Normal file
View File

@ -0,0 +1,35 @@
using Microsoft.AspNetCore.Components;
using TIAMWebApp.Shared.Application.Interfaces;
namespace TIAMWebApp.Shared.Application.Services;
public abstract class ComponentUpdateServiceBase : IComponentUpdateService
{
protected Dictionary<Type, IComponentUpdateItem> ComponentsByType = [];
public virtual void CallRequestRefreshAll()
{
foreach (var component in ComponentsByType.Values)
component.CallRequestRefresh();
}
public void CallRequestRefresh<T>() where T : class, IComponent
{
if (ComponentsByType.TryGetValue(typeof(T), out var componentUpdateItem))
componentUpdateItem.CallRequestRefresh();
}
public IComponentUpdateItem GetOrAddComponent<T>() where T : class, IComponent
{
var componentType = typeof(T);
if (ComponentsByType.TryGetValue(componentType, out var componentUpdateItem))
return componentUpdateItem;
componentUpdateItem = new ComponentUpdateItem();
ComponentsByType.Add(componentType, componentUpdateItem);
return componentUpdateItem;
}
}

401
TIAMWebApp/Shared/Services/UserDataServiceClientBase.cs Normal file
View File

@ -0,0 +1,401 @@
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using AyCode.Interfaces.StorageHandlers;
using AyCode.Services.Loggers;
using Newtonsoft.Json;
using TIAM.Models.Dtos.Users;
using TIAMWebApp.Shared.Application.Interfaces;
using TIAMWebApp.Shared.Application.Models;
using TIAMWebApp.Shared.Application.Models.ClientSide;
using TIAMWebApp.Shared.Application.Models.PageModels;
using TIAMWebApp.Shared.Application.Utility;
namespace TIAMWebApp.Shared.Application.Services;
public abstract class UserDataServiceClientBase : IUserDataService
{
protected readonly HttpClient Http;
protected readonly LoggerClient Logger;
protected readonly ISessionService SessionService;
protected readonly ISecureStorageHandler SecureStorageHandler;
protected readonly IServiceProviderDataService ServiceProviderDataService;
protected UserDataServiceClientBase(HttpClient http, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
{
Http = http;
SessionService = sessionService;
SecureStorageHandler = secureStorageHandler;
ServiceProviderDataService = serviceProviderDataService;
Logger = new LoggerClient(this.GetType().Name, logWriters.ToArray());
}
public async Task<UserSessionModel> IsLoggedInAsync(Guid id)
{
//api call to get user
var userModelDto = await GetUserDetailByIdAsync(id);
if (userModelDto != null)
{
var userProperties = new Dictionary<Guid, string>();
//get user's properties
var hasProperties = userModelDto.ServiceProviders.Count > 0 ? true : (userModelDto.ServiceProviders.Count == 0 ? false : false);
if (hasProperties)
{
//var Properties = await serviceProviderDataService.GetPropertiesByOwnerIdAsync(userModelDto.Id);
var properties = userModelDto.ServiceProviders;
Logger.Info($"{properties.Count} properties found");
foreach (var property in properties)
{
userProperties.Add(property.Id, property.Name);
}
}
//create user session model
var user = new UserSessionModel(userModelDto.Id, UserType.User, userModelDto, userProperties, 1);
return user;
}
else
{
return null;
}
}
public async Task<string> TestUserApi(int Param)
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.UserTest}";
var response = await Http.PostAsJsonAsync(url, Param);
var result = await response.Content.ReadAsStringAsync();
return result;
}
public async Task<string> AuthenticateUser(LoginModel loginModel)
{
var result = string.Empty;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.AuthenticateUser}";
var response = await Http.PostAsJsonAsync(url, loginModel);
//try
//{
// Logger.Detail("Login started: " + "Email: " + loginModel.Email + ", Password: " + loginModel.Password);
//}
//catch (Exception ex)
//{
// _logger.Error(ex.Message, ex);
//}
if (response.IsSuccessStatusCode)
{
result = await response.Content.ReadAsStringAsync();
}
else
{
result = await response.Content.ReadAsStringAsync();
}
//result = await response.Content.ReadAsStringAsync();
return result;
}
public async Task<(bool isSuccess, string ErrorMessage)> CreateUser(RegistrationModel regModel)
{
var isSuccess = true;
var result = string.Empty;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateUser}";
Logger.Info("CreateUser url: " + url);
var response = await Http.PostAsJsonAsync(url, regModel);
result = await response.Content.ReadAsStringAsync();
/*if (response.IsSuccessStatusCode)
{
isSuccess = true;
result = await response.Content.ReadAsStringAsync();
}
else
{
isSuccess = false;
result = await response.Content.ReadAsStringAsync();
}*/
return (isSuccess, result);
}
public async Task<(bool isSuccess, UserModelDto? user)> CreateGuestUser(RegistrationModel regModel)
{
var isSuccess = false;
var result = string.Empty;
var user = new UserModelDto();
var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateGuestUser}";
Logger.Info("CreateGuestUser url: " + url);
var response = await Http.PostAsJsonAsync(url, regModel);
if (response.IsSuccessStatusCode)
{
isSuccess = true;
result = await response.Content.ReadAsStringAsync();
Logger.Info("CreateGuestUser result: " + result);
user = JsonConvert.DeserializeObject<UserModelDto>(result);
}
else
{
isSuccess = false;
result = await response.Content.ReadAsStringAsync();
user = null;
}
return (isSuccess, user);
}
public async Task<List<UserModelDto>?> GetUsersAsync()
{
return await Http.GetFromJsonAsync<List<UserModelDto>>(APIUrls.GetUsers);
}
public async Task<List<UserModelDtoDetail>> GetUsersWithDetailsAsync()
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUsersWithDetails}";
Logger.Info("GetUserByEmailAsync url: " + url + "!");
var response = await Http.GetFromJsonAsync<List<UserModelDtoDetail>>(APIUrls.GetUsersWithDetails);
//var result = await response.Content.ReadAsStringAsync();
//var user = JsonConvert.DeserializeObject<UserModelDto>(result);
return response ?? [];
}
public async Task<UserModelDto?> GetUserByEmailAsync(string email)
{
try
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserByEmail}/{email}";
Logger.Info("GetUserByEmailAsync url: " + url + ", " + email);
var response = await Http.GetAsync(url);
response.EnsureSuccessStatusCode();
if (response.Content != null)
{
var jsonResponse = await response.Content.ReadAsStringAsync();
var user = System.Text.Json.JsonSerializer.Deserialize<UserModelDto>(jsonResponse, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
return user;
}
else
{
return null;
}
}
catch (HttpRequestException httpRequestException)
{
// Handle specific HTTP request exceptions
Logger.DebugConditional($"Request error: {httpRequestException.Message}");
throw;
}
catch (Exception ex)
{
// Handle other possible exceptions
Logger.DebugConditional($"An error occurred: {ex.Message}");
throw;
}
}
public async Task<UserModelDto?> GetUserByIdAsync(Guid id)
{
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserById}";
Logger.Info("GetUserByIdAsync url: " + url + ", " + id.ToString());
var response = await Http.PostAsJsonAsync(url, id);
var result = await response.Content.ReadAsStringAsync();
var user = JsonConvert.DeserializeObject<UserModelDto>(result);
return user;
}
public async Task<UserModelDtoDetail?> GetUserDetailByIdAsync(Guid id)
{
Logger.Info("GetUserDetailByIdAsync", "GLOBAL_LOGGER");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserDetailById}";
Logger.Info("GetUserDetailByIdAsync url: " + url + ", " + id.ToString());
var response = await Http.PostAsJsonAsync(url, id);
//var result = await response.Content.ReadAsStringAsync();
var result = await response.Content.ReadFromJsonAsync<UserModelDtoDetail>();
//var user = JsonConvert.DeserializeObject<UserModelDtoDetail>(result);
return result;
}
public async Task<bool> RefreshToken()
{
Logger.Info("RefreshToken() called");
var isTokenRefreshed = false;
var url = $"{Setting.ApiBaseUrl}/{APIUrls.RefreshToken}";
//var url = APIUrls.RefreshToken;
var serializedStr = JsonConvert.SerializeObject(new AuthenticateRequestAndResponse
{
RefreshToken = Setting.UserBasicDetails.RefreshToken,
AccessToken = Setting.UserBasicDetails.AccessToken
});
try
{
Logger.Info("Refreshtoken url: " + url);
var response = await Http.PostAsync(url, new StringContent(serializedStr, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
var contentStr = await response.Content.ReadAsStringAsync();
var mainResponse = JsonConvert.DeserializeObject<MainResponse>(contentStr);
if (mainResponse.IsSuccess)
{
var tokenDetails = JsonConvert.DeserializeObject<AuthenticateRequestAndResponse>(mainResponse.Content.ToString());
Setting.UserBasicDetails.AccessToken = tokenDetails.AccessToken;
Setting.UserBasicDetails.RefreshToken = tokenDetails.RefreshToken;
var userDetailsStr = JsonConvert.SerializeObject(Setting.UserBasicDetails);
await SecureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userDetailsStr);
isTokenRefreshed = true;
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
Logger.Error("Refreshtoken exception: " + ex.Message, ex);
}
return isTokenRefreshed;
}
public async Task<bool> Logout(string? refreshToken)
{
Logger.Info($"Logout called; refreshToken: {refreshToken}");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.LogoutUser}";
var result = false;
var response = await Http.PostAsJsonAsync(url, refreshToken);
if (response.IsSuccessStatusCode)
{
var resultMessage = await response.Content.ReadAsStringAsync();
Logger.Detail($"Logout response: {resultMessage}");
if (resultMessage == "OK")
{
result = true;
}
else
{
result = false;
}
}
else
{
result = false;
}
Logger.Detail($"Logout: {result}");
return result;
}
public async Task<bool> SendForgottenPasswordMail(string emailAddress)
{
Logger.Info("SendForgottenPasswordMail() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendForgottenPasswordMail}";
var response = await Http.PostAsJsonAsync(url, emailAddress);
var success = await response.Content.ReadFromJsonAsync<bool>();
Logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
return success;
}
public async Task<string> ValidateForgotPasswordToken(Guid userId, string token)
{
var result = "";
Logger.Info("ValidateForgotPasswordToken() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.ValidateForgottenPasswordToken}";
var parameters = new[] { userId.ToString(), token };
var response = await Http.PostAsJsonAsync(url, parameters);
result = await response.Content.ReadAsStringAsync();
Logger.Detail($"ValidateForgotPasswordToken(): {result}");
return result;
}
public async Task<bool> SetEmailConfirmed(Guid userId)
{
var result = false;
Logger.Info("SetEmailConfirmed() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SetEmailConfirmed}";
var response = await Http.PostAsJsonAsync(url, userId);
result = await response.Content.ReadFromJsonAsync<bool>();
Logger.Detail($"ValidateForgotPasswordToken(): {result.ToString()}");
return result;
}
public async Task<bool> SendWelcomeMail(string emailAddress)
{
Logger.Info("SendWelcomeMail() called");
var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendWelcomeMail}";
var response = await Http.PostAsJsonAsync(url, emailAddress);
var success = await response.Content.ReadFromJsonAsync<bool>();
Logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
return success;
}
/*public Task<Dictionary<int, string>> GetUserRolesAsync(UserModel userModel)
{
//TODO: finish this
//get the userModel's roles
int role = userModel.UserRoles;
foreach (var roleType in roleTypes)
{
if ((role & roleType.Id) == roleType.Id)
{
//add the role to the dictionary
userRoleTypes.Add(roleType.Id, roleType.RoleName);
}
}
return Task.FromResult(userRoleTypes);
}*/
}