414 lines
15 KiB
C#
414 lines
15 KiB
C#
using System.Net.Http.Json;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using AyCode.Core.Extensions;
|
|
using AyCode.Interfaces.StorageHandlers;
|
|
using AyCode.Services.Loggers;
|
|
using Microsoft.IdentityModel.Tokens;
|
|
using Newtonsoft.Json;
|
|
using TIAM.Models.Dtos.Users;
|
|
using TIAM.Services;
|
|
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 AdminSignalRClient AdminSignalRClient;
|
|
|
|
protected readonly ISessionService SessionService;
|
|
protected readonly ISecureStorageHandler SecureStorageHandler;
|
|
protected readonly IServiceProviderDataService ServiceProviderDataService;
|
|
|
|
|
|
protected UserDataServiceClientBase(HttpClient http, AdminSignalRClient adminSignalRClient, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
|
|
{
|
|
Http = http;
|
|
AdminSignalRClient = adminSignalRClient;
|
|
|
|
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) return 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;
|
|
}
|
|
|
|
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<MainResponse?> AuthenticateUser(LoginModel loginModel)
|
|
{
|
|
Logger.Debug($"AuthenticateUser; email: {loginModel.Email}");
|
|
|
|
return await AdminSignalRClient.PostDataAsync<LoginModel, MainResponse>(SignalRTags.AuthenticateUser, 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.Debug("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.Debug("CreateGuestUser url: " + url);
|
|
|
|
var response = await Http.PostAsJsonAsync(url, regModel);
|
|
|
|
if (response.IsSuccessStatusCode)
|
|
{
|
|
isSuccess = true;
|
|
result = await response.Content.ReadAsStringAsync();
|
|
Logger.Debug("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()
|
|
{
|
|
Logger.Debug($"GetUsersAsync");
|
|
|
|
return await AdminSignalRClient.GetAllAsync<List<UserModelDto>>(SignalRTags.GetAllUserModelDto) ?? [];
|
|
|
|
//return await Http.GetFromJsonAsync<List<UserModelDto>>(APIUrls.GetUsers);
|
|
}
|
|
|
|
public async Task<List<UserModelDtoDetail>> GetUsersWithDetailsAsync()
|
|
{
|
|
Logger.Debug($"GetUsersWithDetailsAsync");
|
|
|
|
return await AdminSignalRClient.GetAllAsync<List<UserModelDtoDetail>>(SignalRTags.GetAllUserModelDtoDetails) ?? [];
|
|
|
|
////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)
|
|
{
|
|
Logger.Debug($"GetUserByEmailAsync; email: {email}");
|
|
|
|
return await AdminSignalRClient.GetByIdAsync<UserModelDto>(SignalRTags.GetUserModelDtoByEmail, 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.IsSuccessStatusCode)
|
|
// {
|
|
// var jsonResponse = await response.Content.ReadAsStringAsync();
|
|
// var user = System.Text.Json.JsonSerializer.Deserialize<UserModelDto>(jsonResponse, new JsonSerializerOptions
|
|
// {
|
|
// PropertyNameCaseInsensitive = true
|
|
// });
|
|
// return user;
|
|
// }
|
|
|
|
// 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)
|
|
{
|
|
Logger.Debug($"GetUserByIdAsync; id: {id}");
|
|
|
|
return await AdminSignalRClient.GetByIdAsync<UserModelDto>(SignalRTags.GetUserModelDtoById, id);
|
|
|
|
//var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserById}";
|
|
//Logger.Debug("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.Debug($"GetUserDetailByIdAsync; id: {id}");
|
|
|
|
return await AdminSignalRClient.GetByIdAsync<UserModelDtoDetail>(SignalRTags.GetUserModelDtoDetailById, id);
|
|
|
|
//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.Debug("RefreshToken() called");
|
|
|
|
var isTokenRefreshed = false;
|
|
MainResponse? mainResponse = null;
|
|
|
|
try
|
|
{
|
|
var postAuthenticationTokens = new AuthenticationTokens
|
|
{
|
|
RefreshToken = Setting.UserBasicDetails.RefreshToken,
|
|
AccessToken = Setting.UserBasicDetails.AccessToken
|
|
};
|
|
|
|
mainResponse = await AdminSignalRClient.PostDataAsync<AuthenticationTokens, MainResponse>(SignalRTags.RefreshToken, postAuthenticationTokens);
|
|
|
|
if (mainResponse is { IsSuccess: true })
|
|
{
|
|
var tokenDetails = mainResponse.Content.ToJson().JsonTo<AuthenticationTokens>();
|
|
if (tokenDetails == null || string.IsNullOrWhiteSpace(tokenDetails.AccessToken) || string.IsNullOrWhiteSpace(tokenDetails.RefreshToken))
|
|
{
|
|
Logger.Error($"Refreshtoken error! tokenDetails == null || string.IsNullOrWhiteSpace(tokenDetails.AccessToken) || string.IsNullOrWhiteSpace(tokenDetails.RefreshToken); AccessToken: {tokenDetails?.AccessToken}; RefreshToken: {tokenDetails?.RefreshToken}");
|
|
}
|
|
else
|
|
{
|
|
Setting.UserBasicDetails.AccessToken = tokenDetails.AccessToken;
|
|
Setting.UserBasicDetails.RefreshToken = tokenDetails.RefreshToken;
|
|
|
|
var userDetailsStr = Setting.UserBasicDetails.ToJson(); //JsonConvert.SerializeObject(Setting.UserBasicDetails);
|
|
await SecureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userDetailsStr);
|
|
isTokenRefreshed = true;
|
|
}
|
|
}
|
|
else Logger.Info($"Refreshtoken is not success! {mainResponse?.ErrorMessage ?? "mainResponse == null"}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error($"Refreshtoken, {mainResponse?.ErrorMessage ?? "mainResponse == null"}! 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);
|
|
|
|
}*/
|
|
} |