public void AuthController_UpdateEmailId_IntegrationTest_AuthorizedServer()
{
//Arrange
var username = "******";
RegisterModel registerModel = new RegisterModel
{
Title = "Mr",
FullName = "SampleName",
UserName = username,
UserRole = "User",
DialCode = "+91",
PhoneNumber = "12341234",
Email = "*****@*****.**",
Password = "******",
UserLocation = "IN",
Status = "Verified",
OTPExp = DateTime.UtcNow.AddMinutes(4),
VerificationCode = "AQAAAAEAACcQAAAAEDpGr4+u/Oik7F6OLHd3Tr03AX+jYRRqNeo48Il9md5wcPFBl+1xpDQLkimghNMogg=="
};
EmailUpdateModel emailUpdateModel = new EmailUpdateModel
{
Email = "*****@*****.**"
};
var expectedCode = "200";
var expectedMessage = "Email and username updated successfully";
//Insert test data
var insert = TH.InsertRegiterModeldata(registerModel).Result;
//Act
var result = TH.GetAuthController().UpdateEmailId(emailUpdateModel, username) as Task <ActionResult>;
var responseData = TH.DeserializedResponceData(result.Result.ToJson());
//Check updated data
var updatedData = BsonSerializer.Deserialize <RegisterModel>(MH.GetSingleObject(Builders <BsonDocument> .Filter.Eq("UserName", emailUpdateModel.Email), "Authentication", "Authentication").Result);
//Assert
Assert.IsNotNull(result.Result);
Assert.AreEqual(responseData.Code, expectedCode);
Assert.AreEqual(responseData.Message, expectedMessage);
Assert.AreEqual(updatedData.Title, registerModel.Title);
Assert.AreEqual(updatedData.FullName, registerModel.FullName);
Assert.AreEqual(updatedData.UserName, emailUpdateModel.Email);
Assert.AreEqual(updatedData.UserRole, registerModel.UserRole);
Assert.AreEqual(updatedData.DialCode, registerModel.DialCode);
Assert.AreEqual(updatedData.PhoneNumber, registerModel.PhoneNumber);
Assert.AreEqual(updatedData.Email, emailUpdateModel.Email);
Assert.AreEqual(updatedData.Password, registerModel.Password);
Assert.AreEqual(updatedData.UserLocation, registerModel.UserLocation);
Assert.AreEqual(updatedData.Status, registerModel.Status);
Assert.AreEqual(updatedData.VerificationCode, registerModel.VerificationCode);
//Delete inserted test data
var checkData = MH.CheckForDatas("UserName", emailUpdateModel.Email, null, null, "Authentication", "Authentication");
if (checkData != null)
{
var delete = MH.DeleteSingleObject(Builders <BsonDocument> .Filter.Eq("UserName", emailUpdateModel.Email), "Authentication", "Authentication");
}
}
public async Task <IActionResult> UpdateEmail(EmailInfoUpdate emailUpdate)
{
var loggedUserUsername = User.Identity.Name;
var updateParameters = new EmailUpdateModel
{
EGN = emailUpdate.EGN,
EmailId = emailUpdate.EmailId,
LoggedUserUsername = loggedUserUsername,
NewStatus = emailUpdate.NewStatus,
PhoneNumber = emailUpdate.PhoneNumber,
FullName = emailUpdate.FullName,
Amount = emailUpdate.Amount
};
var doWeUpdateValidData = await processingService.ValidateEmailTimeStamp(emailUpdate.EmailId, emailUpdate.CurrentDataStamp);
if (!doWeUpdateValidData)
{
this.TempData["executionMessage"] = "The data you are trying to access has been changed, this is the latest version.";
return(RedirectToAction("GetEmailInfo", "EmailInfo", new { emailId = emailUpdate.EmailId }));
}
var success = await processingService.ProcessEmailUpdate(updateParameters);
if (success)
{
this.TempData["executionMessage"] = "";
return(RedirectToAction("GetEmailInfo", "EmailInfo", new { emailId = emailUpdate.EmailId }));
}
return(BadRequest());
}
public async Task ProcessEmailUpdateShouldReturnFalseWhenInvalidNameIsPassed()
{
var options = new DbContextOptionsBuilder <TBIContext>().UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null, null, null, null, null, null);
var encrypter = new Mock <IEncrypter>();
var validator = new Mock <IValidator>();
var emailService = new Mock <IEmailService>().Object;
var date = DateTime.Now;
var email = new Application
{
Id = 1,
Received = date,
Email = "*****@*****.**",
ApplicationStatus = ApplicationStatus.Open,
Body = "test text",
OperatorId = "1",
LastChange = date
};
var updateParameters = new EmailUpdateModel
{
EmailId = 1,
LoggedUserUsername = "******",
Amount = 23,
NewStatus = "Accepted",
EGN = "1111111111",
PhoneNumber = "0876281932",
FullName = "Ivan Petrov3123"
};
var user = new User {
Id = "1", UserName = "******"
};
userManager.Setup(g => g.FindByNameAsync("testUser")).Returns(Task.FromResult(user));
userManager.Setup(g => g.IsInRoleAsync(user, "Operator")).Returns(Task.FromResult(true));
validator.Setup(d => d.ValidateEGN("1111111111")).Returns(Task.FromResult(true));
validator.Setup(d => d.ValidatePhone("0876281932")).Returns(Task.FromResult(true));
validator.Setup(d => d.ValidateName("Ivan Petrov3123")).Returns(Task.FromResult(false));
using (var arrangeContex = new TBIContext(options))
{
arrangeContex.Applications.Add(email);
await arrangeContex.SaveChangesAsync();
}
using (var assertContext = new TBIContext(options))
{
var sut = new EmailProcessingService(assertContext, encrypter.Object, userManager.Object, validator.Object, emailService);
var executionResult = await sut.ProcessEmailUpdate(updateParameters);
Assert.AreEqual(false, executionResult);
}
}
public async Task <bool> ProcessEmailUpdate(EmailUpdateModel parameters)
{
var emailToBeUpdated = await context.Applications.FindAsync(parameters.EmailId);
var currentLoggedUser = await userManager.FindByNameAsync(parameters.LoggedUserUsername);
var listOfPermittedStatuses = await ReturnPermitedUpdates(emailToBeUpdated.ApplicationStatus, currentLoggedUser);
if (!listOfPermittedStatuses.Contains(parameters.NewStatus))
{
return(false);
}
var permitionGranted = await IsTheLoggedUserPermitedToUpdateTheEmail(currentLoggedUser, emailToBeUpdated);
if (permitionGranted)
{
await UpdateApplication(parameters.NewStatus, emailToBeUpdated, currentLoggedUser);
if (parameters.NewStatus == ApplicationStatus.Open.ToString())
{
var success = await UpdateApplicationProperties(parameters.PhoneNumber, parameters.EGN, emailToBeUpdated);
if (!success)
{
return(false);
}
}
if (emailToBeUpdated.ApplicationStatus == ApplicationStatus.Accepted)
{
if (!await validator.ValidateName(parameters.FullName))
{
return(false);
}
await this.IssueAccount(emailToBeUpdated.Email, emailToBeUpdated.Phone, emailToBeUpdated.EGN, parameters.FullName);
await this.IssueLoan(emailToBeUpdated.Email, parameters.Amount);
}
emailToBeUpdated.LastChange = DateTime.Now;
await context.SaveChangesAsync(currentLoggedUser);
return(true);
}
return(false);
}
public async Task <IActionResult> UpdateTDSEmailData(EmailUpdateModel model)
{
try
{
if (model == null)
{
return(BadRequest());
}
var Update = await _tdsService.UpdateTDSEmailData(model);
return(Ok(Update));
}
catch (Exception Ex)
{
throw Ex;
}
}
public async Task <ResponseModel> UpdateTDSEmailData(EmailUpdateModel model)
{
try
{
var Getdata = await _dBContext.TblAllTdsEmails.Where(f => f.MailId == model.MailId).Include(f => f.Tds).FirstOrDefaultAsync();
if (Getdata == null)
{
return(new ResponseModel {
ResponseMessage = "Mailing Tds Not Found", StatusCode = Convert.ToInt32(HttpStatusCode.NotFound)
});
}
if (Getdata.TdsIsMailSended == true)
{
return(new ResponseModel {
ResponseMessage = "Update failed due to Mail already sended", StatusCode = Convert.ToInt32(HttpStatusCode.IMUsed)
});
}
_mapper.Map <EmailUpdateModel, TblAllTdsEmail>(model, Getdata);
if (Getdata.TdsPdfName != null)
{
string filePath = _configuration.GetSection("KeyValue").GetSection("PhysicalPath").Value;
string fileVirtualPathQP = _configuration.GetSection("KeyValue").GetSection("QPVirtualPath").Value;
Getdata.TdsPdfUrl = fileVirtualPathQP + "/" + Getdata.Tds?.TdsTxnId + "/" + Getdata.TdsPdfName.ToString().Trim() + ".pdf";
}
Getdata.UpdatedBy = "Administrator"; Getdata.UpdatedOn = DateTime.Now;
_dBContext.Update <TblAllTdsEmail>(Getdata);
await _dBContext.SaveChangesAsync();
return(new ResponseModel {
ResponseMessage = "Updated succesfully", StatusCode = Convert.ToInt32(HttpStatusCode.Created)
});
}
catch (Exception Ex)
{
throw Ex;
}
}
