public async Task <IActionResult> Signin([FromBody] TokenRequest request)
{
var result = new ApiResponse <CredentialResponse>();
if (!ModelState.IsValid)
{
result.AddError(ModelState);
return(Ok(result));
}
var authWithToken = await authneticateService.IsAuthenticatedAsync(request);
if (authWithToken.IsAuthenticated)
{
var credentialReponse = new CredentialResponse
{
Token = authWithToken.Token
};
result.AddData(credentialReponse);
return(Ok(result));
}
result.AddError("Invalid Account");
return(Ok(result));
}
/// <summary>
/// Retrieve customer by IBAN
/// </summary>
/// <param name="iban"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <ApiResponse <CustomerResponse> > GetCustomerByIBANAsync(string iban, CancellationToken cancellationToken = default)
{
var responseModel = new ApiResponse <CustomerResponse>();
var bankAccount = await _bankAccountRepo.FindByIBANAsync(iban);
if (bankAccount == null)
{
responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(bankAccount), $"bank Account of IBAN: {iban} not found"));
return(responseModel);
}
var customer = await _customerRepo.FindByIBANAsync(iban);
if (customer == null)
{
responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(customer), $"bank Account's holder of IBAN: {iban} not found"));
return(responseModel);
}
var address = await _addressRepo.FindByIdAsync(customer.AddressId);
responseModel.Data = CreateCustomerResponse(customer, address);
return(responseModel);
}
public async Task <ActionResult <ApiResponse <SignInApiModel.Response> > > SignIn(SignInApiModel.Request request)
{
var response = new ApiResponse <SignInApiModel.Response>();
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
response.AddError(2);
return(response);
}
var result = await _signInManager.PasswordSignInAsync(user, request.Password, false, false);
if (result.Succeeded == false)
{
response.AddError(3);
return(response);
}
response.Data = new SignInApiModel.Response();
response.Data.AccessToken = _tokenService.GenerateAccessToken(await user.GetClaimsAsync(_userManager));
response.Data.RefreshToken = _tokenService.GenerateRefreshToken();
user.RefreshToken = response.Data.RefreshToken;
await _userManager.UpdateAsync(user);
return(Ok(response));
}
/// <summary>
/// Login user
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <ApiResponse <LoginResponse> > LoginAsync(LoginRequest request, CancellationToken cancellationToken)
{
var apiResponse = new ApiResponse <LoginResponse>();
var user = await _userManager.FindByNameAsync(request.CustomerNo);
if (user == null)
{
apiResponse.AddError(ExceptionCreator.CreateUnauthorizedError("Invalid login credentials"));
return(apiResponse);
}
var result = await _signInManager.PasswordSignInAsync(user, request.Password, false, true);
if (result.Succeeded)
{
apiResponse.Data = new LoginResponse()
{
AccessToken = _tokenService.GenerateAccessToken(await user.GetClaimsAsync(_userManager)),
RefreshToken = _tokenService.GenerateRefreshToken()
};
user.RefreshToken = apiResponse.Data.RefreshToken;
await _userManager.UpdateAsync(user);
}
else
{
apiResponse.AddError(ExceptionCreator.CreateUnauthorizedError("Invalid login attempt"));
return(apiResponse);
}
return(apiResponse);
}
public async Task <ActionResult <ApiResponse> > ChangePassword(ChangePasswordApiModel.Request requestModel)
{
var user = await _userManager.GetUserAsync(User);
var responseModel = new ApiResponse();
var correctPassword = await _userManager.CheckPasswordAsync(user, requestModel.OldPassword);
if (correctPassword == false)
{
responseModel.AddError(6);
return(Ok(responseModel));
}
var result = await _userManager.ChangePasswordAsync(user, requestModel.OldPassword, requestModel.NewPassword);
if (result.Succeeded == false)
{
// TODO: Get the errors out
responseModel.AddError(7);
}
else
{
user.RefreshToken = null;
await _userManager.UpdateAsync(user);
}
return(Ok(responseModel));
}
public async Task <IActionResult> GetBankAccountFastTransactions([FromRoute] string iban,
[FromQuery] int pageNumber = PagingConstants.DefaultPageNumber,
[FromQuery] int pageSize = PagingConstants.DefaultPageSize,
CancellationToken cancellationToken = default)
{
var user = await _userManager.GetUserAsync(User);
var customer = await _customerService.GetCustomerByIBANAsync(iban, cancellationToken);
var apiResponse = new ApiResponse <FastTransactionListResponse>();
if (customer == null)
{
apiResponse.AddError(ExceptionCreator.CreateNotFoundError(nameof(customer)));
return(NotFound(apiResponse));
}
if (user.Id != customer?.Data?.UserId)
{
apiResponse.AddError(ExceptionCreator.CreateBadRequestError(nameof(user), "user is not authorized to complete this operation"));
return(BadRequest(apiResponse));
}
try
{
var bankAccount = await _bankAccountService.GetBankAccountByIBANAsync(iban);
if (bankAccount.Data == null)
{
return(NotFound());
}
apiResponse = await _fastTransactionsService.GetBankAccountFastTransactionsAsync(iban, pageNumber, pageSize, cancellationToken);
if (!apiResponse.Success)
{
return(BadRequest(apiResponse));
}
var pagedResponse = new PagedResponse <FastTransactionListResponse>(apiResponse.Data);
return(Ok(pagedResponse));
}
catch (Exception exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, exception.ToString()));
}
}
public async Task <ActionResult <ApiResponse <GetProfileApiModel.Response> > > GetProfileByUserId(string id)
{
var user = await _userManager.FindByIdAsync(id);
var responseModel = new ApiResponse <GetProfileApiModel.Response>();
if (user == null)
{
responseModel.AddError(5);
return(Ok(responseModel));
}
var profile = await _dataAccess.Profiles.FirstOrDefaultAsync(profile => profile.UserId == user.Id);
if (profile != null)
{
responseModel.Data = new GetProfileApiModel.Response()
{
Id = profile.Id,
Address = profile.Address,
FirstName = profile.FirstName,
LastName = profile.LastName,
// TODO: Add the proper rating
Rating = 0
};
}
return(Ok(responseModel));
}
public async Task <ApiResponse <bool> > UpdateUserExamStatus(Guid userExamId)
{
var result = new ApiResponse <bool>();
try
{
var userExam = await dbContext.UserExams.FirstOrDefaultAsync(e => e.Id == userExamId);
if (userExam != null)
{
userExam.Status = Models.DB.Exams.enums.Status.Completed;
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
}
else
{
result.Data = false;
result.AddMessage("Exam not enrolled yet");
}
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <ExamViewModel> > > Get()
{
var result = new ApiResponse <List <ExamViewModel> >();
try
{
result.Data = await dbContext.Exams
.Select(e => new ExamViewModel
{
Id = e.Id,
Title = e.Title,
Description = e.Description,
Duration = e.Duration,
ImageUrl = e.ImageUrl,
Status = e.Status,
CreatedDate = e.CreatedDate
})
.ToListAsync();
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
/// <summary>
/// forgot password request
/// </summary>
/// <param name="email"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <Response> ForgotPasswordAsync(string email, CancellationToken cancellationToken)
{
var apiResponse = new ApiResponse <ForgotPasswordResponse>();
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
apiResponse.AddError(ExceptionCreator.CreateNotFoundError(nameof(user), $"user not found"));
return(apiResponse);
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
var encodedToken = Encoding.UTF8.GetBytes(token);
var validToken = WebEncoders.Base64UrlEncode(encodedToken);
string url = $"{_configuration["AppUrl"]}/reset-password?email={email}&token={validToken}";
await _mailService.SendEmailAsync(email, "Reset Password", "<h1>Follow the instructions to reset your passwod</h1>" +
$"<p>To reset your password <a href='{url}'>Click here</a></p>", cancellationToken);
return(apiResponse);
}
public override async Task Validate(RegisterAccountRequestModel command)
{
if (string.IsNullOrEmpty(command.Email))
{
ApiResponse.AddError(nameof(RegisterAccountRequestModel.Email), "The email is required.");
}
else if (!new EmailAddressAttribute().IsValid(command.Email))
{
ApiResponse.AddError(nameof(RegisterAccountRequestModel.Email), "The email address is not valid.");
}
else if (await userDataService.EmailIsUsed(command.Email))
{
ApiResponse.AddError(nameof(RegisterAccountRequestModel.Email), "Email is already used.");
}
if (string.IsNullOrEmpty(command.Password))
{
ApiResponse.AddError(nameof(RegisterAccountRequestModel.Password), "The password is required.");
}
if (string.IsNullOrEmpty(command.ConfirmPassword))
{
ApiResponse.AddError(nameof(RegisterAccountRequestModel.ConfirmPassword), "The confirm password is required.");
}
else if (command.Password != command.ConfirmPassword)
{
ApiResponse.AddError(nameof(RegisterAccountRequestModel.ConfirmPassword), "The passwords must match.");
}
}
public async Task <ApiResponse <List <QuestionViewModel> > > Get()
{
var result = new ApiResponse <List <QuestionViewModel> >();
try
{
result.Data = await dbContext.Questions
.Include(a => a.Options)
.Select(q => new QuestionViewModel
{
Id = q.Id,
Title = q.Title,
Type = q.Type,
Options = q.Options,
RatePolicy = q.RatePolicy
})
.ToListAsync();
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ActionResult <ApiResponse <SignUpApiModel.Response> > > SignUp(SignUpApiModel.Request request)
{
var response = new ApiResponse <SignUpApiModel.Response>();
if (await checkEmail(request.Email))
{
response.AddError(1);
return(response);
}
var appUser = new AppUser()
{
Email = request.Email,
UserName = request.Email
};
var result = await _userManager.CreateAsync(appUser, request.Password);
if (result.Succeeded == false)
{
// TODO:
return(NotFound());
}
response.Data = new SignUpApiModel.Response()
{
Email = request.Email
};
return(Ok(response));
}
public async Task <ActionResult <ApiResponse> > DeleteBookImage(int bookImageId)
{
var responseModel = new ApiResponse();
var user = await _userManager.GetUserAsync(User);
var bookImage = await _dataAccess.BookImages
.Include(b => b.Book)
.FirstOrDefaultAsync(b => (b.Id == bookImageId && b.Book.AppUserId == user.Id) && bookImageId != b.Book.BookImageId);
if (bookImage == null)
{
responseModel.AddError(11);
return(Ok(responseModel));
}
var pathToFile = Directory.GetCurrentDirectory() + "\\wwwroot" + _imagesFolderPath + bookImage.ImageName;
System.IO.File.Delete(pathToFile);
_dataAccess.BookImages.Remove(bookImage);
await _dataAccess.SaveChangesAsync();
return(Ok(responseModel));
}
/// <summary>
/// Retrieve country for the specified id
/// </summary>
/// <param name="countryId"></param>
/// <param name="includeCities"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <ApiResponse <CountryResponse> > GetCountryByIdAsync(int countryId, bool includeCities = false, CancellationToken cancellationToken = default)
{
var responseModel = new ApiResponse <CountryResponse>();
Country country = null;
if (includeCities)
{
country = await _countriesRepo.FindByIdWithCitiesAsync(countryId);
}
else
{
country = await _countriesRepo.FindByIdAsync(countryId);
}
if (country == null)
{
responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(country), $"country of id {countryId}: not found"));
return(responseModel);
}
if (includeCities)
{
responseModel.Data = await CreateCountryWithCitiesResponse(country);
}
else
{
responseModel.Data = CreateCountryResponse(country);
}
return(responseModel);
}
public async Task <ApiResponse <bool> > UdpateExam(ExamViewModel exam)
{
var result = new ApiResponse <bool>();
try
{
var oExam = new Exam
{
Id = exam.Id,
Title = exam.Title,
Status = exam.Status,
Description = exam.Description,
Duration = exam.Duration,
ImageUrl = exam.ImageUrl
};
dbContext.Exams.Update(oExam);
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public override async Task Validate(AddAssetCommand command)
{
if (!deviceTypeDataService.Exists(command.Model.DeviceTypeId))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.DeviceTypeId), "The device type is not valid.");
return;
}
if (string.IsNullOrEmpty(command.Model.Name))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.Name), "The name is required.");
}
else if (await repository.GetEntities <UserAssetEntity>().AnyAsync(x =>
x.UserId == command.UserId &&
EF.Functions.Like(x.Asset.Name.ToLower(), $"{command.Model.Name.ToLower()}")))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.Name),
"You already have an asset with the same name.");
}
if (string.IsNullOrEmpty(command.Model.DeviceId))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.DeviceId),
"The device id is required.");
}
else if (await deviceService.DeviceIsUsed(command.Model.DeviceId, command.Model.DeviceTypeId))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.DeviceId),
"The device id is already used by another device on the same protocol.");
}
}
public async Task <ApiResponse <List <Option> > > GetOptionsByQuestion(Guid questionId, Guid userExamId)
{
var result = new ApiResponse <List <Option> >();
try
{
var response = dbContext.Options.
Where(o => o.Question.Id == questionId).ToList()
.Select(e => { e.IsCorrect = false; return(e); }).ToList();
var optionSelected = dbContext.UserAnswers
.Where(e => (e.Option.QuestionId == questionId && e.UserExamId == userExamId));
if (optionSelected.Count() == 0)
{
result.Data = response;
result.AddSuccess();
}
else
{
result.Data = null;
result.AddMessage("Question answered already");
}
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <ExamQuestionViewModel> > > GetQuestionsByExam(Guid examId)
{
var result = new ApiResponse <List <ExamQuestionViewModel> >();
try
{
var oList = await dbContext.ExamQuestions
.Where(ex => ex.ExamId == examId)
.Include(e => e.Question)
.Include(e => e.Exam)
.Select(e => new ExamQuestionViewModel
{
ExamId = e.ExamId,
QuestionId = e.QuestionId,
Exam = e.Exam.Title,
Question = e.Question.Title,
Type = e.Question.Type,
RatePolicy = e.Question.RatePolicy
})
.ToListAsync();
result.Data = oList;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ActionResult <ApiResponse <GetBookApiModel.Response> > > GetBookById(int bookId)
{
var responseModel = new ApiResponse <GetBookApiModel.Response>();
var book = await _dataAccess.Books.Include(b => b.BookImage).Include(b => b.BookImages).FirstOrDefaultAsync(b => b.Disabled != true && b.Id == bookId);
if (book == null)
{
responseModel.AddError(8);
return(Ok(responseModel));
}
responseModel.Data = new GetBookApiModel.Response()
{
Author = book.Author,
BookId = book.Id,
Condition = book.Condition,
Description = book.Description,
Title = book.Title,
Year = book.Year,
BookImages = book.BookImages.Select(bi => new GetBookApiModel.BookImage
{
BookImageId = bi.Id,
ImagePath = $"{_imagesFolderPath}{bi.ImageName}",
IsCover = bi.Id == book.BookImageId
}).ToList()
};
return(Ok(responseModel));
}
public override Task Validate(UpdateUserCommand command)
{
if (!command.Model.MeasurementSystem.HasValue ||
!Enum.IsDefined(typeof(MeasurementSystem), command.Model.MeasurementSystem.Value))
{
ApiResponse.AddError(nameof(command.Model.MeasurementSystem), "The value provided is not valid.");
}
return(Task.CompletedTask);
}
public async Task <IActionResult> GetBankAccountCashTransactions([FromRoute] string iban,
[FromQuery] int lastDays,
[FromQuery] int pageNumber = PagingConstants.DefaultPageNumber,
[FromQuery] int pageSize = PagingConstants.DefaultPageSize,
CancellationToken cancellationToken = default)
{
try
{
var apiResponse = new ApiResponse <CashTransactionListResponse>();
var user = await _userManager.GetUserAsync(User);
var customer = await _customerService.GetCustomerByIBANAsync(iban, cancellationToken);
if (customer == null)
{
apiResponse.AddError(ExceptionCreator.CreateNotFoundError(nameof(customer)));
return(NotFound(apiResponse));
}
if (user.Id != customer?.Data?.UserId)
{
apiResponse.AddError(ExceptionCreator.CreateForbiddenError(nameof(user), "user is not authorized to perform operation"));
return(Forbid());
}
apiResponse = await _cashTransactionsService.GetBankAccountCashTransactionsAsync(iban, lastDays, pageNumber, pageSize, cancellationToken);
if (apiResponse.Success)
{
var pagedApiResponse = new PagedResponse <CashTransactionListResponse>(apiResponse.Data);
return(Ok(pagedApiResponse));
}
return(BadRequest(apiResponse));
}
catch (Exception exception)
{
return(_actionResultMapper.Map(exception));
}
}
public async Task <ApiResponse <bool> > SubmitUserAnswer(List <UserAnswerViewModel> userAnswer)
{
var result = new ApiResponse <bool>();
try
{
var proceed = false;
for (var i = 0; i < userAnswer.Count; i++)
{
var currentUseranswer = await dbContext.UserAnswers
.FirstOrDefaultAsync(a => (a.OptionId == userAnswer[0].OptionId &&
a.UserExamId == userAnswer[0].UserExamId));
if (currentUseranswer == null)
{
var checkAnswer = await dbContext.Options.FindAsync(userAnswer[0].OptionId);
if (checkAnswer.IsCorrect)
{
var checkUserExam = await dbContext.UserExams.FirstOrDefaultAsync(ue => ue.Id == userAnswer[0].UserExamId);
checkUserExam.Score = checkUserExam.Score + checkAnswer.Score;
}
var oUserAnswer = new UserAnswer
{
OptionId = userAnswer[i].OptionId,
UserExamId = userAnswer[i].UserExamId
};
await dbContext.AddAsync(oUserAnswer);
result.AddSuccess();
result.Data = true;
proceed = true;
}
else
{
result.Data = false;
result.AddMessage("Answer Already Exist");
}
}
if (proceed)
{
await dbContext.SaveChangesAsync();
}
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
/// <summary>
/// Create a deposit transaction in db
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <Response> MakeDepositAsync(CreateCashTransactionRequest request, CancellationToken cancellationToken = default)
{
var responseModel = new ApiResponse <CashTransactionResponse>();
var amountToDeposit = request.Amount;
var dbContextTransaction = await _dbContext.Database.BeginTransactionAsync(cancellationToken);
try
{
var toAccount = await _bankAccountRepo.FindByIBANAsync(request.To);
if (toAccount == null)
{
responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(toAccount)));
return(responseModel);
}
//Add amount to recipient balance
toAccount.Balance += amountToDeposit;
toAccount.AllowedBalanceToUse += amountToDeposit;
//Update bank account
await _bankAccountRepo.UpdateAsync(_dbContext, toAccount);
//Add transaction to db & save changes
await _cashTransactionsRepo.AddAsync(_dbContext, CreateCashTransaction(request, 0, toAccount.Balance));
await dbContextTransaction.CommitAsync(cancellationToken);
return(responseModel);
}
catch (Exception ex)
{
await dbContextTransaction.RollbackAsync(cancellationToken);
responseModel.AddError(ExceptionCreator.CreateInternalServerError(ex.ToString()));
return(responseModel);
}
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
{
var result = new ApiResponse <Empty>();
if (!ModelState.IsValid)
{
result.AddError(ModelState);
return(Ok(result));
}
var createResult = await userManagerService.CreateUserAsync(model.Email, model.Password);
if (createResult.RegisterResult.Succeeded)
{
return(Ok(result));
}
result.AddError(createResult.RegisterResult.Errors);
return(Ok(result));
}
public async Task <IActionResult> GetLastCashTransactions([FromRoute] string iban,
CancellationToken cancellationToken = default)
{
try
{
var apiResponse = new ApiResponse <LastCashTransactionListResponse>();
var user = await _userManager.GetUserAsync(User);
var customer = await _customerService.GetCustomerByIBANAsync(iban, cancellationToken);
if (customer == null)
{
apiResponse.AddError(ExceptionCreator.CreateNotFoundError(nameof(customer)));
return(NotFound(apiResponse));
}
if (user.Id != customer?.Data?.UserId)
{
apiResponse.AddError(ExceptionCreator.CreateBadRequestError(nameof(user), "user is not authorized to perform operation"));
return(BadRequest(apiResponse));
}
apiResponse = await _cashTransactionsService.GetLastCashTransactionsAsync(iban, cancellationToken);
if (apiResponse.Success)
{
return(Ok(apiResponse));
}
return(BadRequest(apiResponse));
}
catch (Exception exception)
{
return(_actionResultMapper.Map(exception));
}
}
public async Task <ActionResult <ApiResponse <EditProfileApiModel.Response> > > EditMyProfile(EditProfileApiModel.Request requestModel)
{
var user = await _userManager.GetUserAsync(User);
var responseModel = new ApiResponse <GetProfileApiModel.Response>();
var profile = await _dataAccess.Profiles.FirstOrDefaultAsync(profile => profile.UserId == user.Id);
if (profile != null)
{
bool editted = false;
if (!string.IsNullOrEmpty(requestModel.FirstName) && requestModel.FirstName != profile.FirstName)
{
editted = true;
profile.FirstName = requestModel.FirstName;
}
if (!string.IsNullOrEmpty(requestModel.LastName) && requestModel.LastName != profile.LastName)
{
editted = true;
profile.LastName = requestModel.LastName;
}
if (!string.IsNullOrEmpty(requestModel.Address) && requestModel.Address != profile.Address)
{
editted = true;
profile.Address = requestModel.Address;
}
if (editted == true)
{
_dataAccess.Profiles.Update(profile);
await _dataAccess.SaveChangesAsync();
}
responseModel.Data = new GetProfileApiModel.Response()
{
Id = profile.Id,
Address = profile.Address,
FirstName = profile.FirstName,
LastName = profile.LastName,
// TODO: Add the proper rating
Rating = 0
};
}
else
{
responseModel.AddError(4);
}
return(Ok(responseModel));
}
public override Task Validate(GetDeviceConnectionsCommand command)
{
if (command.Page < 1)
{
ApiResponse.AddError(nameof(DeviceConnectionRequestModel.Page), "The Page property must be >= 1.");
}
if (command.PerPage < 10 || command.PerPage > 100)
{
ApiResponse.AddError(nameof(DeviceConnectionRequestModel.PerPage),
"The PerPage property must be between 10 and 100.");
}
return(Task.CompletedTask);
}
public override async Task Validate(RenameAssetCommand command)
{
if (string.IsNullOrEmpty(command.Model.Name))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.Name), "The name is required.");
}
else if (await repository.GetEntities <UserAssetEntity>().AnyAsync(x =>
x.AssetId != command.AssetId &&
x.UserId == command.UserId &&
EF.Functions.Like(x.Asset.Name.ToLower(), $"{command.Model.Name.ToLower()}")))
{
ApiResponse.AddError(nameof(AddAssetRequestModel.Name),
"You already have an asset with the same name.");
}
}
/// <summary>
/// Retrieve debit card by id
/// </summary>
/// <param name="debitCardId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <ApiResponse <DebitCardResponse> > GetDebitCardByIdAsync(int debitCardId, CancellationToken cancellationToken = default)
{
var responseModel = new ApiResponse <DebitCardResponse>();
var debitCard = await _debitCardsRepo.FindByIdAsync(debitCardId);
if (debitCard == null)
{
responseModel.AddError(ExceptionCreator.CreateNotFoundError(nameof(DebitCard), $"Debit card of id: {debitCardId}: is not found"));
return(responseModel);
}
responseModel.Data = CreateDebitCardResponse(debitCard);
return(responseModel);
}
