public static async Task <OperationResult <string> > UploadInCustomePath(IFormFile file, string formatextExtention, string fileName, params string[] Paths)
{
if (file.Length > 0)
{
var name = fileName + formatextExtention;
if (!Directory.Exists(UploadFolderPath.PathUploadFolder()))
{
Directory.CreateDirectory(UploadFolderPath.PathUploadFolder());
}
foreach (var item in Paths)
{
if (!Directory.Exists(item))
{
Directory.CreateDirectory(Paths.Last());
}
}
var result = await Upload(file, name, Paths.Last());
if (result.Success)
{
return(OperationResult <string> .BuildSuccessResult(result.Result));
}
}
return(OperationResult <string> .BuildFailure("File Not Exist"));
}
public async Task <OperationResult <string> > Handle(DeleteRoleCommand request, CancellationToken cancellationToken)
{
var role = await unitOfWork.RoleRepository.GetRoleByIdAsync(request.Id, cancellationToken);
if (role.Result != null)
{
role.Result.Delete();
role.Result.UpdateSecurityStamp();
var update = unitOfWork.RoleRepository.Update(role.Result, cancellationToken);
if (update.Success)
{
try
{
await unitOfWork.CommitSaveChangeAsync();
return(OperationResult <string> .BuildSuccessResult("Success Delete"));
}
catch (Exception ex)
{
return(OperationResult <string> .BuildFailure(ex));
}
}
}
return(OperationResult <string> .BuildFailure(role.ErrorMessage));
}
public async Task <OperationResult <string> > Handle(SetAccessLevelCommand request, CancellationToken cancellationToken)
{
var result = await unitOfWork.RoleRepository.AccessLevelRepository.SetAccess(new AccessLevelDto { RoleId = request.RoleId, Access = request.AccessList });
if (result.Success)
{
try
{
var findRole = await unitOfWork.RoleRepository.GetRoleByIdAsync(request.RoleId, cancellationToken);
findRole.Result.UpdateSecurityStamp();
if (findRole.Result != null)
{
unitOfWork.RoleRepository.Update(findRole.Result, cancellationToken);
await unitOfWork.CommitSaveChangeAsync();
return(OperationResult <string> .BuildSuccessResult("Add Success"));
}
}
catch (Exception ex)
{
return(OperationResult <string> .BuildFailure(ex.Message));
}
}
return(OperationResult <string> .BuildFailure(result.ErrorMessage));
}
public async Task <OperationResult <GetAllPaging <GetAllBrands> > > GetAllBrandPaging(GetAllFormQuery formQuery, CancellationToken cancellation)
{
try
{
var res = Brands.Select(c => new GetAllBrands
{
BrandName = c.BrandName,
CategoryName = c.Category.Name,
Id = c.Id,
CategoryId = c.CategoryId,
IsoBrandName = c.IsoBrandName
});
var sieveModel = new SieveModel
{
PageSize = formQuery.PageSize,
Filters = formQuery.Filters,
Page = formQuery.Page,
Sorts = formQuery.Sorts
};
var result = sieveProcessor.Apply(sieveModel, res);
return(OperationResult <GetAllPaging <GetAllBrands> > .BuildSuccessResult(new GetAllPaging <GetAllBrands>
{
Records = result,
TotalCount = await Brands.CountAsync()
}));
}
catch (Exception ex)
{
return(OperationResult <GetAllPaging <GetAllBrands> > .BuildFailure(ex.Message));
}
}
public async Task <OperationResult <FoodCreateCommandResult> > Handle(FoodCreateCommand request, CancellationToken cancellationToken)
{
try
{
var food = new Food(request.Name, new Mony(request.Price), request.FoodType)
{
Description = request.Description
};
food.UpdatePrice(new Mony(request.Price));
var newfood = await _db.Foods.AddAsync(food);
// await _db.SaveChangesAsync();
var result = OperationResult <FoodCreateCommandResult>
.BuildSuccessResult(new FoodCreateCommandResult
{
FoodId = newfood.Entity.ID
});
return(result);
}
catch (Exception ex)
{
var exResult = OperationResult <FoodCreateCommandResult> .BuildFailure(ex);
return(exResult);
}
}
public async Task <OperationResult <FoodCreateCommandResult> > Handle(FoodCreateCommand request, CancellationToken cancellationToken)
{
var food = new Food(request.Name, new Money(request.Price), request.FoodType)
{
Description = request.Description
};
try
{
var newFoodId = await _uow.FoodRepository.Create(food);// await _db.Foods.AddAsync(food);
await _uow.CommitAsync();
var result = OperationResult <FoodCreateCommandResult>
.BuildSuccessResult(new FoodCreateCommandResult
{
FoodId = newFoodId
});
await Task.CompletedTask;
return(result);
}
catch (Exception ex)
{
var exResult = OperationResult <FoodCreateCommandResult> .BuildFailure(ex);
return(exResult);
}
}
public async Task <OperationResult <string> > Handle(UserActivationcCodeRequestCommand request, CancellationToken cancellationToken)
{
var result = await unitOfWork.UsersRepository.GetUserByPhoneNumberAsync(request.PhoneNumber, cancellationToken);
if (result.Result != null)
{
ActivationCode acCode = new ActivationCode(result.Result.Id, CodeTypes.PhoneConfirmed, Utility.Hash(result.Result.Username));
var gerateActivationCode = await unitOfWork.UsersRepository.ActivationCodeRepository.AddAsync(acCode, cancellationToken);
if (gerateActivationCode.Success)
{
var registerSetting = await unitOfWork.SettingRepository.Get <RegisterUserSetting>(SettingEnum.RegisterUserSetting.EnumToString(), cancellationToken);
if (registerSetting.Success)
{
SendNotif sendNotif = sendNotifs.Where(x => x.SendCodeType == registerSetting.Result.SendCodeVerifications)
.FirstOrDefault();
var sendCode = await sendNotif.SendCodeAsync(gerateActivationCode.Result.Item2.ToString(), request.PhoneNumber, cancellationToken);
if (sendCode.Success)
{
/// Save to Database
await unitOfWork.CommitSaveChangeAsync();
return(OperationResult <string> .BuildSuccessResult(gerateActivationCode.Result.Item1));
}
return(OperationResult <string> .BuildFailure(sendCode.ErrorMessage));
}
return(OperationResult <string> .BuildFailure(registerSetting.ErrorMessage));
}
return(OperationResult <string> .BuildFailure(gerateActivationCode.ErrorMessage));
}
return(OperationResult <string> .BuildFailure("User Not found"));
}
public async Task <OperationResult <bool> > Handle(UpdateUserRoleCommand request, CancellationToken cancellationToken)
{
var getUserRole = await unitOfWork.UsersRepository.UsersRoleRepository.GetByUserId(request.UserId);
if (getUserRole.Result != null)
{
getUserRole.Result.SetValues(request.RoleId, request.UserId);
var updateUserRole = unitOfWork.UsersRepository.UsersRoleRepository.UpdateUserRole(getUserRole.Result);
if (updateUserRole.Success)
{
var findUSer = await unitOfWork.UsersRepository.GetUserByIdAsync(request.UserId, cancellationToken);
if (findUSer.Success)
{
findUSer.Result.UpdateSecurityStamp();
try
{
await unitOfWork.CommitSaveChangeAsync();
}
catch (Exception ex)
{
return(OperationResult <bool> .BuildFailure(ex));
}
}
return(OperationResult <bool> .BuildSuccessResult(true));
}
return(OperationResult <bool> .BuildFailure(updateUserRole.ErrorMessage));
}
return(OperationResult <bool> .BuildFailure(getUserRole.ErrorMessage));
}
/// <summary>
/// Send Email Notifiaction
/// </summary>
/// <param name="from"></param>
/// <param name="subject"></param>
/// <param name="content"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="to"></param>
/// <param name="port"></param>
/// <param name="smtpServer"></param>
/// <returns></returns>
public override async Task <OperationResult <string> > Send(string from, string subject, string content, string userName, string password, MailboxAddress to, int port, string smtpServer)
{
using (var client = new SmtpClient())
{
var emailMessage = new MimeMessage();
try
{
client.Connect(smtpServer, port, true);
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(userName, password);
emailMessage.From.Add(new MailboxAddress(from));
emailMessage.To.Add(to);
emailMessage.Subject = subject;
emailMessage.Body = new TextPart(MimeKit.Text.TextFormat.Text)
{
Text = content
};
}
catch (Exception ex)
{
return(OperationResult <string> .BuildFailure(ex));
}
finally
{
await client.DisconnectAsync(true);
client.Dispose();
}
}
return(OperationResult <string> .BuildSuccessResult("Success Send Email"));
}
public async Task <OperationResult <TokenInfo> > GetUserTokenInfo(Guid id)
{
try
{
var userInfo = await Users.Where(x => x.Id == id)
.Select(x => new
{
IsActive = x.IsActive,
UserName = x.Username,
UserSecurotyStamp = x.SecurityStamp,
UserId = x.Id,
Role = x.UserRoles.Role
}).Select(c => new TokenInfo
{
RoleId = c.Role.Id,
UserId = c.UserId,
UserName = c.UserName,
IsActive = c.IsActive,
UserSecurityStamp = c.UserSecurotyStamp,
RoleSecurityStamp = c.Role.SecurityStamp,
AccessLevels = c.Role.AccessLevels.Where(x => x.RoleId == c.Role.Id).Select(x => x.Access).ToList()
}).FirstOrDefaultAsync();
return(OperationResult <TokenInfo> .BuildSuccessResult(userInfo));
}
catch (Exception ex)
{
return(OperationResult <TokenInfo> .BuildFailure(ex.Message));
}
}
public async Task <OperationResult <bool> > Handle(UpdateUserCommand request, CancellationToken cancellationToken)
{
string fileName = null;
var getUser = await unitOfWork.UsersRepository.GetUserByIdAsync(request.Id, cancellationToken);
if (getUser.Result != null)
{
if (request.Photo != null)
{
var uploadFile = await UploadUtiltie.UploadInCustomePath(request.Photo, ".png", request.Username, UploadFolderPath.PathUserUploadFolder(), UploadFolderPath.PathAvatarUserUploadFolder());
fileName = uploadFile.Result;
}
getUser.Result.UpdateProperties(request.Username, request.Name, request.Family, request.Email, fileName);
var addUser = unitOfWork.UsersRepository.Update(getUser.Result, cancellationToken);
if (addUser.Success)
{
try
{
unitOfWork.CommitSaveChange();
return(OperationResult <bool> .BuildSuccessResult(true));
}
catch (Exception ex)
{
return(OperationResult <bool> .BuildFailure(ex.Message));
}
}
}
return(OperationResult <bool> .BuildFailure(getUser.ErrorMessage));
}
public async Task <OperationResult <string> > Handle(CreateUserCommand request, CancellationToken cancellationToken)
{
string fileName = null;
if (request.Photo != null)
{
var uploadFile = await UploadUtiltie.UploadInCustomePath(request.Photo, ".png", request.Username, UploadFolderPath.PathUserUploadFolder(), UploadFolderPath.PathAvatarUserUploadFolder());
fileName = uploadFile.Result;
}
/// Register User
var user = new User(request.Username, request.Password, request.Name, request.Family, request.PhoneNumber, request.Email, fileName);
var addUser = await unitOfWork.UsersRepository.AddAsync(user, cancellationToken);
if (addUser.Success)
{
try
{
var registerSetting = await unitOfWork.SettingRepository.Get <RegisterUserSetting>(SettingEnum.RegisterUserSetting.EnumToString(), cancellationToken);
if (registerSetting.Result != null)
{
/// Add User Role
var addUserRole = await mediator.Send(new CreateUserRoleCommand(registerSetting.Result.RegisterRoleByAdmin, user.Id));
if (addUserRole.Success)
{
/// Add User Generation Code
ActivationCode acCode = new ActivationCode(user.Id, CodeTypes.PhoneConfirmed, Utility.Hash(user.Username));
var gerateActivationCode = await unitOfWork.UsersRepository.ActivationCodeRepository.AddAsync(acCode, cancellationToken);
if (gerateActivationCode.Success)
{
/// Send Registration Code
SendNotif sendNotif = sendNotifs.Where(x => x.SendCodeType == registerSetting.Result.SendCodeVerifications)
.FirstOrDefault();
var sendCode = await sendNotif.SendCodeAsync(gerateActivationCode.Result.Item2.ToString(), user.PhoneNumber, cancellationToken);
if (sendCode.Success)
{
/// Save to Database
await unitOfWork.CommitSaveChangeAsync();
return(OperationResult <string> .BuildSuccessResult(gerateActivationCode.Result.Item1));
}
}
}
}
}
catch (Exception ex)
{
return(OperationResult <string> .BuildFailure(ex.Message));
}
}
return(OperationResult <string> .BuildFailure(addUser.ErrorMessage));
}
public async Task <OperationResult <IEnumerable <CategoryProperty> > > Handle(GetAllCategoryPropertyCommand request, CancellationToken cancellationToken)
{
var getAllCategoryProperty = await unitOfWork.CategoryRepository.CategoryPropertyRepository.GetAllCategoryPropertybyCategoryId(request.CategoryPropertyId, cancellationToken);
if (getAllCategoryProperty.Success)
{
return(OperationResult <IEnumerable <CategoryProperty> > .BuildSuccessResult(getAllCategoryProperty.Result));
}
return(OperationResult <IEnumerable <CategoryProperty> > .BuildFailure(getAllCategoryProperty.ErrorMessage));
}
public async Task <OperationResult <User> > Handle(GerUserByIdQuery request, CancellationToken cancellationToken)
{
var result = await unitOfWork.UsersRepository.GetUserByIdAsync(request.Id, cancellationToken);
if (result.Success)
{
return(OperationResult <User> .BuildSuccessResult(result.Result));
}
return(OperationResult <User> .BuildFailure(result.ErrorMessage));
}
public async Task <OperationResult <GetAllPaging <Role> > > Handle(GetRoleListPagingQuery request, CancellationToken cancellationToken)
{
var role = await unitOfWork.RoleRepository.GetAllRolePagingAsync(request, cancellationToken);
if (role.Result != null)
{
return(OperationResult <GetAllPaging <Role> > .BuildSuccessResult(role.Result));
}
return(OperationResult <GetAllPaging <Role> > .BuildFailure(role.ErrorMessage));
}
public async Task <OperationResult <string> > Handle(CreatePostMagazineCommands request, CancellationToken cancellationToken, RequestHandlerDelegate <OperationResult <string> > next)
{
var findUserName = await unitOfWork.CategoryRepository.GetCategoryByIdAsync(request.CategoryId, cancellationToken);
if (findUserName.Result != null)
{
return(OperationResult <string> .BuildFailure("Category NotFound"));
}
return(await next());
}
public async Task <OperationResult <IEnumerable <Role> > > Handle(GetAllRoleQuery request, CancellationToken cancellationToken)
{
var result = await unitOfWork.RoleRepository.GetAllRole(cancellationToken);
if (result.Success)
{
return(OperationResult <IEnumerable <Role> > .BuildSuccessResult(result.Result));
}
return(OperationResult <IEnumerable <Role> > .BuildFailure(result.ErrorMessage));
}
public async Task <OperationResult <RegisterUserSetting> > Handle(RegisterUserSettingQuery request, CancellationToken cancellationToken)
{
var result = await unitOfWork.SettingRepository.Get <RegisterUserSetting>(SettingEnum.RegisterUserSetting.EnumToString(), cancellationToken);
if (result.Result != null)
{
return(OperationResult <RegisterUserSetting> .BuildSuccessResult(result.Result));
}
return(OperationResult <RegisterUserSetting> .BuildFailure("Empty"));
}
public async Task <OperationResult <string> > Handle(SetRegisterUserSettingCommand request, CancellationToken cancellationToken, RequestHandlerDelegate <OperationResult <string> > next)
{
var findRegisterUserRole = await unitOfWork.RoleRepository.GetRoleByIdAsync(request.RegisterRoleByUser, cancellationToken);
if (findRegisterUserRole.Result == null)
{
return(OperationResult <string> .BuildFailure("RegisterRoleByUser not valid role"));
}
return(await next());
}
public async Task <OperationResult <string> > Handle(CreateUserCommand request, CancellationToken cancellationToken, RequestHandlerDelegate <OperationResult <string> > next)
{
var findUserName = await unitOfWork.UsersRepository.GetUserByEmailAsync(request.Email, cancellationToken);
if (findUserName.Result != null)
{
return(OperationResult <string> .BuildFailure("email Exist"));
}
return(await next());
}
public async Task <OperationResult <IEnumerable <PostMagazine> > > Handle(GetPostByCategoryIdQuery request, CancellationToken cancellationToken)
{
var findPost = await unitOfWork.PostMagazineRepository.GetAllPostMagazineByCategory(request.categoryId, cancellationToken);
if (findPost.Result != null)
{
return(OperationResult <IEnumerable <PostMagazine> > .BuildSuccessResult(findPost.Result));
}
return(OperationResult <IEnumerable <PostMagazine> > .BuildFailure(findPost.ErrorMessage));
}
public async Task <OperationResult <UserInformationDto> > Handle(UserInformationCommand request, CancellationToken cancellationToken)
{
var information = await unitOfWork.UsersRepository.GetUserInformation(request.Id);
if (information.Success)
{
return(OperationResult <UserInformationDto> .BuildSuccessResult(information.Result));
}
return(OperationResult <UserInformationDto> .BuildFailure(information.ErrorMessage));
}
public async Task <OperationResult <IEnumerable <Brand> > > Handle(GetBrandByCategoryId request, CancellationToken cancellationToken)
{
var getbrand = await unitOfWork.CategoryRepository.BrandRepository.GetAllBrandsByCategoryId(request.categoryId, cancellationToken);
if (getbrand.Success)
{
return(OperationResult <IEnumerable <Brand> > .BuildSuccessResult(getbrand.Result));
}
return(OperationResult <IEnumerable <Brand> > .BuildFailure(getbrand.ErrorMessage));
}
public async Task <OperationResult <string> > Handle(UpdatePhoneNumberCommand request, CancellationToken cancellationToken, RequestHandlerDelegate <OperationResult <string> > next)
{
var findUserName = await unitOfWork.UsersRepository.GetUserByIdAsync(request.UserId, cancellationToken);
if (findUserName.Result.PhoneNumber != request.PhoneNumber)
{
return(OperationResult <string> .BuildFailure("phoneNumber Exist"));
}
return(await next());
}
public async Task <OperationResult <GetAllPaging <GetAllBrands> > > Handle(GetAllBrandPaging request, CancellationToken cancellationToken)
{
var getbrand = await unitOfWork.CategoryRepository.BrandRepository.GetAllBrandPaging(request, cancellationToken);
if (getbrand.Success)
{
return(OperationResult <GetAllPaging <GetAllBrands> > .BuildSuccessResult(getbrand.Result));
}
return(OperationResult <GetAllPaging <GetAllBrands> > .BuildFailure(getbrand.ErrorMessage));
}
public async Task <OperationResult <bool> > Handle(CreateUserRoleCommand request, CancellationToken cancellationToken)
{
var add = await unitOfWork.UsersRepository.UsersRoleRepository.AddAsync(new UserRole(request.RoleId, request.UserId), cancellationToken);
if (add.Success)
{
return(OperationResult <bool> .BuildSuccessResult(true));
}
return(OperationResult <bool> .BuildFailure(add.ErrorMessage));
}
public OperationResult AddMove(Move move)
{
var fork = Board.MoveSnake(CurrentDirection);
if (fork.Success)
{
var moveAdded = Moves.Add(move);
return(moveAdded ? OperationResult.BuildSuccess() : OperationResult.BuildFailure(ErrorType.MoveAlreadyExsited));
}
return(OperationResult.BuildFailure(fork.ErrorMessage));
}
public OperationResult <bool> Update(User role, CancellationToken cancellation)
{
try
{
Users.Update(role);
return(OperationResult <bool> .BuildSuccessResult(true));
}
catch (Exception ex)
{
return(OperationResult <bool> .BuildFailure(ex.Message));
}
}
public OperationResult <string> UpdateUserRole(UserRole userRole)
{
try
{
context.Update(userRole);
return(OperationResult <string> .BuildSuccessResult("Update Success"));
}
catch (Exception ex)
{
return(OperationResult <string> .BuildFailure(ex.Message));
}
}
public OperationResult <string> UpdateBrandAsync(Brand brand, CancellationToken cancellation)
{
try
{
Brands.Update(brand);
return(OperationResult <string> .BuildSuccessResult("Update Brand"));
}
catch (Exception ex)
{
return(OperationResult <string> .BuildFailure(ex.Message));
}
}
