initial commit

Core/Application/Features/SecurityManager/Commands/ConfirmEmail.cs

@@ -0,0 +1,55 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class ConfirmEmailResult
+{
+    public string? Email { get; init; }
+}
+
+public class ConfirmEmailRequest : IRequest<ConfirmEmailResult>
+{
+    public required string Email { get; init; }
+    public required string Code { get; init; }
+}
+
+public class ConfirmEmailValidator : AbstractValidator<ConfirmEmailRequest>
+{
+    public ConfirmEmailValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty()
+            .EmailAddress();
+
+        RuleFor(x => x.Code)
+            .NotEmpty();
+    }
+}
+
+
+public class ConfirmEmailHandler : IRequestHandler<ConfirmEmailRequest, ConfirmEmailResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public ConfirmEmailHandler(
+        ISecurityService securityService
+        )
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<ConfirmEmailResult> Handle(ConfirmEmailRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.ConfirmEmailAsync(
+            request.Email,
+            request.Code,
+            cancellationToken
+            );
+
+        return new ConfirmEmailResult { Email = result };
+    }
+}
+

Core/Application/Features/SecurityManager/Commands/CreateUser.cs

@@ -0,0 +1,67 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class CreateUserResult
+{
+    public CreateUserResultDto? Data { get; set; }
+}
+
+public class CreateUserRequest : IRequest<CreateUserResult>
+{
+    public string? Email { get; init; }
+    public string? Password { get; init; }
+    public string? ConfirmPassword { get; init; }
+    public string? FirstName { get; init; }
+    public string? LastName { get; init; }
+    public bool? EmailConfirmed { get; init; }
+    public bool? IsBlocked { get; init; }
+    public bool? IsDeleted { get; init; }
+    public string? CreatedById { get; init; }
+}
+
+public class CreateUserValidator : AbstractValidator<CreateUserRequest>
+{
+    public CreateUserValidator()
+    {
+        RuleFor(x => x.Email).NotEmpty();
+        RuleFor(x => x.Password).NotEmpty();
+        RuleFor(x => x.ConfirmPassword).NotEmpty();
+        RuleFor(x => x.FirstName).NotEmpty();
+        RuleFor(x => x.LastName).NotEmpty();
+    }
+}
+
+public class CreateUserHandler : IRequestHandler<CreateUserRequest, CreateUserResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public CreateUserHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<CreateUserResult> Handle(CreateUserRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.CreateUserAsync(
+            request.Email ?? "",
+            request.Password ?? "",
+            request.ConfirmPassword ?? "",
+            request.FirstName ?? "",
+            request.LastName ?? "",
+            request.EmailConfirmed ?? true,
+            request.IsBlocked ?? false,
+            request.IsDeleted ?? false,
+            request.CreatedById ?? "",
+            cancellationToken
+            );
+
+        return new CreateUserResult
+        {
+            Data = result
+        };
+    }
+}

Core/Application/Features/SecurityManager/Commands/DeleteUser.cs

@@ -0,0 +1,51 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class DeleteUserResult
+{
+    public DeleteUserResultDto? Data { get; set; }
+}
+
+public class DeleteUserRequest : IRequest<DeleteUserResult>
+{
+    public string? UserId { get; init; }
+    public string? DeletedById { get; init; }
+}
+
+public class DeleteUserValidator : AbstractValidator<DeleteUserRequest>
+{
+    public DeleteUserValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+    }
+}
+
+public class DeleteUserHandler : IRequestHandler<DeleteUserRequest, DeleteUserResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public DeleteUserHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<DeleteUserResult> Handle(DeleteUserRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.DeleteUserAsync(
+            request.UserId ?? "",
+            request.DeletedById ?? "",
+            cancellationToken
+            );
+
+        return new DeleteUserResult
+        {
+            Data = result
+        };
+    }
+}
+
+

Core/Application/Features/SecurityManager/Commands/ForgotPassword.cs

@@ -0,0 +1,52 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class ForgotPasswordResult
+{
+    public string? Data { get; init; }
+}
+
+public class ForgotPasswordRequest : IRequest<ForgotPasswordResult>
+{
+    public required string Email { get; init; }
+}
+
+public class ForgotPasswordValidator : AbstractValidator<ForgotPasswordRequest>
+{
+    public ForgotPasswordValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty()
+            .EmailAddress();
+    }
+}
+
+
+public class ForgotPasswordHandler : IRequestHandler<ForgotPasswordRequest, ForgotPasswordResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public ForgotPasswordHandler(
+        ISecurityService securityService
+        )
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<ForgotPasswordResult> Handle(ForgotPasswordRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.ForgotPasswordAsync(
+            request.Email,
+            cancellationToken
+            );
+
+        return new ForgotPasswordResult
+        {
+            Data = result
+        };
+    }
+}

Core/Application/Features/SecurityManager/Commands/ForgotPasswordConfirmation.cs

@@ -0,0 +1,60 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class ForgotPasswordConfirmationResult
+{
+    public string? Email { get; init; }
+}
+
+public class ForgotPasswordConfirmationRequest : IRequest<ForgotPasswordConfirmationResult>
+{
+    public required string Email { get; init; }
+    public required string TempPassword { get; init; }
+    public required string Code { get; init; }
+}
+
+public class ForgotPasswordConfirmationValidator : AbstractValidator<ForgotPasswordConfirmationRequest>
+{
+    public ForgotPasswordConfirmationValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty()
+            .EmailAddress();
+
+        RuleFor(x => x.TempPassword)
+            .NotEmpty();
+
+        RuleFor(x => x.Code)
+            .NotEmpty();
+    }
+}
+
+
+public class ForgotPasswordConfirmationHandler : IRequestHandler<ForgotPasswordConfirmationRequest, ForgotPasswordConfirmationResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public ForgotPasswordConfirmationHandler(
+        ISecurityService securityService
+        )
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<ForgotPasswordConfirmationResult> Handle(ForgotPasswordConfirmationRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.ForgotPasswordConfirmationAsync(
+            request.Email,
+            request.TempPassword,
+            request.Code,
+            cancellationToken
+            );
+
+        return new ForgotPasswordConfirmationResult { Email = result };
+    }
+}
+

Core/Application/Features/SecurityManager/Commands/Logout.cs

@@ -0,0 +1,46 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+public class LogoutResult
+{
+    public LogoutResultDto? Data { get; set; }
+}
+
+public class LogoutRequest : IRequest<LogoutResult>
+{
+    public string? UserId { get; init; }
+}
+
+public class LogoutValidator : AbstractValidator<LogoutRequest>
+{
+    public LogoutValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+    }
+}
+
+public class LogoutHandler : IRequestHandler<LogoutRequest, LogoutResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public LogoutHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<LogoutResult> Handle(LogoutRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.LogoutAsync(
+            request.UserId ?? "",
+            cancellationToken
+            );
+
+        return new LogoutResult
+        {
+            Data = result
+        };
+    }
+}

Core/Application/Features/SecurityManager/Commands/RefreshToken.cs

@@ -0,0 +1,47 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Queries;
+
+
+public class RefreshTokenResult
+{
+    public RefreshTokenResultDto? Data { get; init; }
+}
+
+public class RefreshTokenRequest : IRequest<RefreshTokenResult>
+{
+    public string? RefreshToken { get; set; }
+}
+
+public class RefreshTokenValidator : AbstractValidator<RefreshTokenRequest>
+{
+    public RefreshTokenValidator()
+    {
+        RuleFor(x => x.RefreshToken).NotEmpty();
+    }
+}
+
+public class RefreshTokenHandler : IRequestHandler<RefreshTokenRequest, RefreshTokenResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public RefreshTokenHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<RefreshTokenResult> Handle(RefreshTokenRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.RefreshTokenAsync(
+            request.RefreshToken ?? "",
+            cancellationToken
+            );
+
+        return new RefreshTokenResult
+        {
+            Data = result
+        };
+    }
+}

Core/Application/Features/SecurityManager/Commands/Register.cs

@@ -0,0 +1,60 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+public class RegisterResult
+{
+    public RegisterResultDto? Data { get; set; }
+}
+
+public class RegisterRequest : IRequest<RegisterResult>
+{
+    public string? Email { get; init; }
+    public string? Password { get; init; }
+    public string? ConfirmPassword { get; init; }
+    public string? FirstName { get; init; }
+    public string? LastName { get; init; }
+    public string? CompanyName { get; init; }
+}
+
+public class RegisterValidator : AbstractValidator<RegisterRequest>
+{
+    public RegisterValidator()
+    {
+        RuleFor(x => x.Email).NotEmpty();
+        RuleFor(x => x.Password).NotEmpty();
+        RuleFor(x => x.ConfirmPassword).NotEmpty();
+        RuleFor(x => x.FirstName).NotEmpty();
+        RuleFor(x => x.LastName).NotEmpty();
+    }
+}
+
+public class RegisterHandler : IRequestHandler<RegisterRequest, RegisterResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public RegisterHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<RegisterResult> Handle(RegisterRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.RegisterAsync(
+            request.Email ?? "",
+            request.Password ?? "",
+            request.ConfirmPassword ?? "",
+            request.FirstName ?? "",
+            request.LastName ?? "",
+            request.CompanyName ?? "",
+            cancellationToken
+            );
+
+        return new RegisterResult
+        {
+            Data = result
+        };
+    }
+}

Core/Application/Features/SecurityManager/Commands/UpdateMyProfile.cs

@@ -0,0 +1,56 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+
+public class UpdateMyProfileResult
+{
+    public string? Data { get; init; }
+}
+
+public class UpdateMyProfileRequest : IRequest<UpdateMyProfileResult>
+{
+    public string? UserId { get; init; }
+    public string? FirstName { get; init; }
+    public string? LastName { get; init; }
+    public string? CompanyName { get; init; }
+}
+
+public class UpdateMyProfileValidator : AbstractValidator<UpdateMyProfileRequest>
+{
+    public UpdateMyProfileValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+        RuleFor(x => x.FirstName).NotEmpty();
+        RuleFor(x => x.LastName).NotEmpty();
+    }
+}
+
+public class UpdateMyProfileHandler : IRequestHandler<UpdateMyProfileRequest, UpdateMyProfileResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public UpdateMyProfileHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<UpdateMyProfileResult> Handle(UpdateMyProfileRequest request, CancellationToken cancellationToken)
+    {
+        await _securityService.UpdateMyProfileAsync(
+            request.UserId ?? "",
+            request.FirstName ?? "",
+            request.LastName ?? "",
+            request.CompanyName ?? "",
+            cancellationToken
+            );
+
+        return new UpdateMyProfileResult
+        {
+            Data = "Update MyProfile Success"
+        };
+    }
+}

Core/Application/Features/SecurityManager/Commands/UpdateMyProfileAvatar.cs

@@ -0,0 +1,52 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+
+public class UpdateMyProfileAvatarResult
+{
+    public string? Data { get; init; }
+}
+
+public class UpdateMyProfileAvatarRequest : IRequest<UpdateMyProfileAvatarResult>
+{
+    public string? UserId { get; init; }
+    public string? Avatar { get; init; }
+}
+
+public class UpdateMyProfileAvatarValidator : AbstractValidator<UpdateMyProfileAvatarRequest>
+{
+    public UpdateMyProfileAvatarValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+        RuleFor(x => x.Avatar).NotEmpty();
+    }
+}
+
+public class UpdateMyProfileAvatarHandler : IRequestHandler<UpdateMyProfileAvatarRequest, UpdateMyProfileAvatarResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public UpdateMyProfileAvatarHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<UpdateMyProfileAvatarResult> Handle(UpdateMyProfileAvatarRequest request, CancellationToken cancellationToken)
+    {
+        await _securityService.ChangeAvatarAsync(
+            request.UserId ?? "",
+            request.Avatar ?? "",
+            cancellationToken
+            );
+
+        return new UpdateMyProfileAvatarResult
+        {
+            Data = "Update Avatar Success"
+        };
+    }
+}
+

Core/Application/Features/SecurityManager/Commands/UpdateMyProfilePassword.cs

@@ -0,0 +1,58 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+
+public class UpdateMyProfilePasswordResult
+{
+    public string? Data { get; init; }
+}
+
+public class UpdateMyProfilePasswordRequest : IRequest<UpdateMyProfilePasswordResult>
+{
+    public string? UserId { get; init; }
+    public string? OldPassword { get; init; }
+    public string? NewPassword { get; init; }
+    public string? ConfirmNewPassword { get; init; }
+}
+
+public class UpdateMyProfilePasswordValidator : AbstractValidator<UpdateMyProfilePasswordRequest>
+{
+    public UpdateMyProfilePasswordValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+        RuleFor(x => x.OldPassword).NotEmpty();
+        RuleFor(x => x.NewPassword).NotEmpty();
+        RuleFor(x => x.ConfirmNewPassword).NotEmpty();
+    }
+}
+
+public class UpdateMyProfilePasswordHandler : IRequestHandler<UpdateMyProfilePasswordRequest, UpdateMyProfilePasswordResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public UpdateMyProfilePasswordHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<UpdateMyProfilePasswordResult> Handle(UpdateMyProfilePasswordRequest request, CancellationToken cancellationToken)
+    {
+        await _securityService.ChangePasswordAsync(
+            request.UserId ?? "",
+            request.OldPassword ?? "",
+            request.NewPassword ?? "",
+            request.ConfirmNewPassword ?? "",
+            cancellationToken
+            );
+
+        return new UpdateMyProfilePasswordResult
+        {
+            Data = "Update Password Success"
+        };
+    }
+}
+

Core/Application/Features/SecurityManager/Commands/UpdatePasswordUser.cs

@@ -0,0 +1,52 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class UpdatePasswordUserResult
+{
+    public string? Data { get; init; }
+}
+
+public class UpdatePasswordUserRequest : IRequest<UpdatePasswordUserResult>
+{
+    public string? UserId { get; init; }
+    public string? NewPassword { get; init; }
+}
+
+public class UpdatePasswordUserValidator : AbstractValidator<UpdatePasswordUserRequest>
+{
+    public UpdatePasswordUserValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+        RuleFor(x => x.NewPassword).NotEmpty();
+    }
+}
+
+public class UpdatePasswordUserHandler : IRequestHandler<UpdatePasswordUserRequest, UpdatePasswordUserResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public UpdatePasswordUserHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<UpdatePasswordUserResult> Handle(UpdatePasswordUserRequest request, CancellationToken cancellationToken)
+    {
+        await _securityService.UpdatePasswordUserAsync(
+            request.UserId ?? "",
+            request.NewPassword ?? "",
+            cancellationToken
+            );
+
+        return new UpdatePasswordUserResult
+        {
+            Data = "Update Password Success"
+        };
+    }
+}
+
+

Core/Application/Features/SecurityManager/Commands/UpdateUser.cs

@@ -0,0 +1,62 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+public class UpdateUserResult
+{
+    public UpdateUserResultDto? Data { get; set; }
+}
+
+public class UpdateUserRequest : IRequest<UpdateUserResult>
+{
+    public string? UserId { get; init; }
+    public string? FirstName { get; init; }
+    public string? LastName { get; init; }
+    public bool? EmailConfirmed { get; init; }
+    public bool? IsBlocked { get; init; }
+    public bool? IsDeleted { get; init; }
+    public string? UpdatedById { get; init; }
+}
+
+public class UpdateUserValidator : AbstractValidator<UpdateUserRequest>
+{
+    public UpdateUserValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+        RuleFor(x => x.FirstName).NotEmpty();
+        RuleFor(x => x.LastName).NotEmpty();
+    }
+}
+
+public class UpdateUserHandler : IRequestHandler<UpdateUserRequest, UpdateUserResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public UpdateUserHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<UpdateUserResult> Handle(UpdateUserRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.UpdateUserAsync(
+            request.UserId ?? "",
+            request.FirstName ?? "",
+            request.LastName ?? "",
+            request.EmailConfirmed ?? true,
+            request.IsBlocked ?? false,
+            request.IsDeleted ?? false,
+            request.UpdatedById ?? "",
+            cancellationToken
+            );
+
+        return new UpdateUserResult
+        {
+            Data = result
+        };
+    }
+}
+

Core/Application/Features/SecurityManager/Commands/UpdateUserRole.cs

@@ -0,0 +1,55 @@
+using Application.Common.Services.SecurityManager;
+using FluentValidation;
+using MediatR;
+
+namespace Application.Features.SecurityManager.Commands;
+
+
+
+public class UpdateUserRoleResult
+{
+    public List<string>? Data { get; set; }
+}
+
+public class UpdateUserRoleRequest : IRequest<UpdateUserRoleResult>
+{
+    public string? UserId { get; init; }
+    public string? RoleName { get; init; }
+    public bool? AccessGranted { get; init; }
+}
+
+public class UpdateUserRoleValidator : AbstractValidator<UpdateUserRoleRequest>
+{
+    public UpdateUserRoleValidator()
+    {
+        RuleFor(x => x.UserId).NotEmpty();
+        RuleFor(x => x.RoleName).NotEmpty();
+    }
+}
+
+public class UpdateUserRoleHandler : IRequestHandler<UpdateUserRoleRequest, UpdateUserRoleResult>
+{
+    private readonly ISecurityService _securityService;
+
+    public UpdateUserRoleHandler(ISecurityService securityService)
+    {
+        _securityService = securityService;
+    }
+
+    public async Task<UpdateUserRoleResult> Handle(UpdateUserRoleRequest request, CancellationToken cancellationToken)
+    {
+        var result = await _securityService.UpdateUserRoleAsync(
+            request.UserId ?? "",
+            request.RoleName ?? "",
+            request.AccessGranted ?? true,
+            cancellationToken
+            );
+
+        return new UpdateUserRoleResult
+        {
+            Data = result
+        };
+    }
+}
+
+