public async Task ShouldCallMediatorToDelete()
{
DeleteApprenticeshipCommand arg = null;
_mockMediator.Setup(x => x.Send(It.IsAny <DeleteApprenticeshipCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new Unit())
.Callback <DeleteApprenticeshipCommand, CancellationToken>((command, token) => arg = command);
_mockMediator.Setup(x => x.Send(It.IsAny <GetApprenticeshipQueryRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetApprenticeshipQueryResponse {
Apprenticeship = new Apprenticeship()
});
var signInUser = new SignInUserModel {
DisplayName = "Bob", Email = "*****@*****.**"
};
await _orchestrator.DeleteApprenticeship("user123", new Web.Models.DeleteConfirmationViewModel
{
ProviderId = 123L,
HashedCommitmentId = "ABBA99",
HashedApprenticeshipId = "ABBA66"
}, signInUser);
_mockMediator.Verify(x => x.Send(It.IsAny <DeleteApprenticeshipCommand>(), It.IsAny <CancellationToken>()), Times.Once);
arg.ProviderId.Should().Be(123);
arg.ApprenticeshipId.Should().Be(321);
arg.UserDisplayName.Should().Be(signInUser.DisplayName);
arg.UserEmailAddress.Should().Be(signInUser.Email);
}
public bool ValidateLoginCredentials(SignInUserModel user)
{
bool credenciaisValidas = false;
if (user != null && !String.IsNullOrWhiteSpace(user.Email))
{
// Verifica a existência do usuário nas tabelas do
// ASP.NET Core Identity
var userIdentity = _userManager
.FindByNameAsync(user.Email).Result;
if (userIdentity != null)
{
// Efetua o login com base no Id do usuário e sua senha
var resultadoLogin = _signInManager
.CheckPasswordSignInAsync(userIdentity, user.Password, false)
.Result;
if (resultadoLogin.Succeeded)
{
// Verifica se o usuário em questão possui
// a role Acesso-APIProdutos
//credenciaisValidas = _userManager.IsInRoleAsync(
// userIdentity, Roles.Admin).Result
// || _userManager.IsInRoleAsync(userIdentity, Roles.Cliente).Result
// || _userManager.IsInRoleAsync(userIdentity, Roles.Prestador).Result;
credenciaisValidas = true;
}
}
}
return(credenciaisValidas);
}
public async Task <IActionResult> SignIn(SignInUserModel signInUserModel)
{
if (ModelState.IsValid)
{
var result = await _accountService.SignInAsync(signInUserModel);
if (!result.Succeeded)
{
if (result.IsNotAllowed)
{
ModelState.AddModelError("", "Not allowed");
}
else
{
ModelState.AddModelError("", "Invalid credentials");
}
return(View(signInUserModel));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
return(View());
}
public async Task <IActionResult> Login(SignInUserModel signInUserModel, string returnUrl)
{
if (signInUserModel.Email.IndexOf('@') > -1)
{
//Validate email format
string emailRegex = @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" +
@"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" +
@".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$";
Regex re = new Regex(emailRegex);
if (!re.IsMatch(signInUserModel.Email))
{
ModelState.AddModelError("Email", "Email is not valid");
}
}
else
{
//validate Username format
string emailRegex = @"^[a-zA-Z0-9]*$";
Regex re = new Regex(emailRegex);
if (!re.IsMatch(signInUserModel.Email))
{
ModelState.AddModelError("Email", "Username is not valid");
}
}
if (ModelState.IsValid)
{
var userName = signInUserModel.Email;
if (userName.IndexOf('@') > -1)
{
var user = await _userManager.FindByEmailAsync(signInUserModel.Email);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(View(signInUserModel));
}
else
{
userName = user.UserName;
}
}
var result = await _signInManager.PasswordSignInAsync(userName, signInUserModel.Password, signInUserModel.RememberMe, false);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Invalid Credintials");
}
return(View(signInUserModel));
}
public async Task <IActionResult> LogIn([FromBody] SignInUserModel loginModel)
{
var result = await signInUserCommand.Execute(loginModel);
if (result.IsSuccessful)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task ShouldCallMediatorPassingInMappedApprenticeships()
{
const string dataLine = "\n\rABBA123,Chris,Froberg,1998-12-08,,,25,2,2020-08,2025-08,1500,,Employer ref,Provider ref,1113335559";
const string fileContents = HeaderLine + dataLine;
var textStream = new MemoryStream(UTF8.GetBytes(fileContents));
_file.Setup(m => m.InputStream).Returns(textStream);
BulkUploadApprenticeshipsCommand commandArgument = null;
_mockMediator.Setup(x => x.Send(It.IsAny <BulkUploadApprenticeshipsCommand>(), new CancellationToken()))
.ReturnsAsync(new Unit())
.Callback <BulkUploadApprenticeshipsCommand, CancellationToken>((command, token) => commandArgument = command);
_mockMediator.Setup(m => m.Send(It.IsAny <GetCommitmentQueryRequest>(), new CancellationToken()))
.Returns(Task.FromResult(new GetCommitmentQueryResponse
{
Commitment = new CommitmentView
{
AgreementStatus = AgreementStatus.NotAgreed,
EditStatus = EditStatus.ProviderOnly
}
}));
var model = new UploadApprenticeshipsViewModel {
Attachment = _file.Object, HashedCommitmentId = "ABBA123", ProviderId = 111
};
var signinUser = new SignInUserModel {
DisplayName = "Bob", Email = "*****@*****.**"
};
await _sut.UploadFile("user123", model, signinUser);
_mockMediator.Verify(x => x.Send(It.IsAny <BulkUploadApprenticeshipsCommand>(), new CancellationToken()), Times.Once);
commandArgument.ProviderId.Should().Be(111);
commandArgument.CommitmentId.Should().Be(123);
commandArgument.Apprenticeships.Should().NotBeEmpty();
commandArgument.Apprenticeships.ToList()[0].FirstName.Should().Be("Chris");
commandArgument.Apprenticeships.ToList()[0].LastName.Should().Be("Froberg");
commandArgument.Apprenticeships.ToList()[0].DateOfBirth.Should().Be(new DateTime(1998, 12, 8));
commandArgument.Apprenticeships.ToList()[0].TrainingType.Should().Be(DAS.Commitments.Api.Types.Apprenticeship.Types.TrainingType.Standard);
commandArgument.Apprenticeships.ToList()[0].TrainingCode.Should().Be("2");
commandArgument.Apprenticeships.ToList()[0].StartDate.Should().Be(new DateTime(2020, 8, 1));
commandArgument.Apprenticeships.ToList()[0].EndDate.Should().Be(new DateTime(2025, 8, 1));
commandArgument.Apprenticeships.ToList()[0].Cost.Should().Be(1500);
commandArgument.Apprenticeships.ToList()[0].ProviderRef.Should().Be("Provider ref");
commandArgument.Apprenticeships.ToList()[0].ULN.Should().Be("1113335559");
commandArgument.UserEmailAddress.Should().Be(signinUser.Email);
commandArgument.UserDisplayName.Should().Be(signinUser.DisplayName);
commandArgument.UserId.Should().Be("user123");
}
public void SignIn(LogonViewModel user)
{
AccountModule module = new AccountModule();
Employee userInfo = module.GetPrototypeEmployeeByAccountID(user.Account, this.PortalDB);
if (userInfo == null)
{
throw new Exception("請輸入正確帳號或密碼");
}
m_user = this.CreateUser(userInfo);
Context.Session["UserInfo"] = m_user;
}
public CustomJsonResult SignIn(SignInUserModel model)
{
SimpleUserDto user = this.userService.GetUserByCredentials(model.Name, model.Password);
if (user == null)
{
return(this.ErrorResult()); //todo: handle this on client
}
this.Session.SetCurrentUserId(user.Id);
FormsAuthentication.SetAuthCookie(model.Name, model.RememberMe);
return(this.SuccessResult());
}
public SuccessUserMessage GetUser(SignInUserModel obj)
{
SuccessUserMessage objuser = new SuccessUserMessage();
try
{
return(_caseService.GetUser(obj.UserName, obj.Password));
}
catch (Exception ex)
{
objuser.Status = false;
objuser.Message = ex.Message.ToString();
return(objuser);
}
}
/// <summary>
/// 建立SignInUserModel實體
/// </summary>
/// <param name="empInfo"></param>
/// <returns></returns>
private SignInUserModel CreateUser(Employee empInfo)
{
AccountModule module = new AccountModule();
string depId = string.Empty;
SignInUserModel user = new SignInUserModel();
user.ID = empInfo.EmployeeID;
user.ADAccount = empInfo.ADAccount;
user.Name = empInfo.EmployeeName;
user.NationalType = empInfo.NationalType;
depId = empInfo.DepartmentID_FK;
user.Department = module.GetDepartmentInfoByID(depId);
user.Roles = module.GetUserRoleAndMenuListByEmpID(user.ID);
user.MenuList = module.GetMenuListByRoleList(user.Roles);
return(user);
}
public ActionResult <object> Post(
[FromBody] SignInUserModel usuario,
[FromServices] AccessManager accessManager)
{
if (accessManager.ValidateLoginCredentials(usuario))
{
ClaimsPrincipal claims = this.User;
return(Ok(accessManager.GenerateToken(usuario, claims)));
}
else
{
return(Unauthorized(new
{
Authenticated = false,
Message = "Falha ao autenticar"
}));
}
}
public async Task <SignInUserResult> Login(SignInUserModel loginModel)
{
var loginAsJson = JsonSerializer.Serialize(loginModel);
var response = await _httpClient.PutAsync("api/Accounts/Login", new StringContent(loginAsJson, Encoding.UTF8, "application/json"));
var loginResult = JsonSerializer.Deserialize <SignInUserResult>(await response.Content.ReadAsStringAsync(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
if (!response.IsSuccessStatusCode)
{
return(loginResult);
}
await _localStorage.SetItemAsync(tokenStore, loginResult.Token);
((ApiAuthStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(loginModel.Email);
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.Token);
return(loginResult);
}
public async Task ShouldCallMediatorToSubmitUndo(bool isApproved)
{
//Arrange
var providerId = 1;
var apprenticeshipId = "appid";
var userId = "tester";
var loginUser = new SignInUserModel {
DisplayName = "Bob", Email = "*****@*****.**"
};
//Act
await _orchestrator.SubmitUndoApprenticeshipUpdate(providerId, apprenticeshipId, userId, loginUser);
//Assert
_mediator.Verify(x => x.Send(
It.Is <UndoApprenticeshipUpdateCommand>(r =>
r.ProviderId == providerId &&
r.UserId == userId &&
r.UserDisplayName == loginUser.DisplayName &&
r.UserEmailAddress == loginUser.Email
), It.IsAny <CancellationToken>()), Times.Once());
}
public async Task <IActionResult> SignIn(SignInUserModel signInUserModel)
{
if (ModelState.IsValid)
{
//Wyszukanie użytkownika
var user = await _userManager.FindByNameAsync(signInUserModel.Email);
//Jeśli mamy tego użytkownika..
if (user != null)
{
//To próbujemy się zalogować
var signInResult = await _signInManager.PasswordSignInAsync(user, signInUserModel.Password, false, false);
if (signInResult.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Niepoprawne dane logowania");
}
return(View(signInUserModel));
}
public async Task ShouldCallMediatorToCreate()
{
var providerId = 123;
string userId = "ABC";
var expectedApprenticeship = new ApprenticeshipUpdate();
var viewModel = new CreateApprenticeshipUpdateViewModel();
var signedInUser = new SignInUserModel()
{
DisplayName = "Bob", Email = "*****@*****.**"
};
_mockApprenticeshipMapper.Setup(x => x.MapApprenticeshipUpdate(viewModel)).Returns(expectedApprenticeship);
await _orchestrator.CreateApprenticeshipUpdate(viewModel, providerId, userId, signedInUser);
_mockMediator.Verify(
x =>
x.Send(
It.Is <CreateApprenticeshipUpdateCommand>(
c =>
c.ProviderId == providerId && c.UserId == userId && c.ApprenticeshipUpdate == expectedApprenticeship && c.UserDisplayName == signedInUser.DisplayName &&
c.UserEmailAddress == signedInUser.Email), It.IsAny <CancellationToken>()), Times.Once);
}
public Token GenerateToken(SignInUserModel user, ClaimsPrincipal claims)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(user.Email, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Email)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(_tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = _tokenConfigurations.Issuer,
Audience = _tokenConfigurations.Audience,
SigningCredentials = _signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(new Token()
{
Authenticated = true,
Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
AccessToken = token,
Message = "OK",
Roles = _userManager.GetRolesAsync(_userManager.FindByNameAsync(user.Email).Result).Result.ToArray <String>()
});
}
public async Task <IActionResult> SignIn([FromBody] SignInUserModel signInUserModel)
{
var signInUser = signInUserModel.ConvertToSignIn();
if (!signInUser.IsValid())
{
return(CustomResponse(signInUser.ValidationResult));
}
var result = await __signInManager.PasswordSignInAsync(signInUser.Email, signInUser.Password, false, true);
if (result.Succeeded)
{
return(CustomResponse(await GenerateJWT(signInUser.Email)));
}
if (result.IsLockedOut)
{
AdicionarErroProcessamento("Usuário temporariamente bloqueado por tentativas inválidas.");
return(CustomResponse());
}
AdicionarErroProcessamento("Usuário ou senha incorretos.");
return(CustomResponse(""));
}
public async Task DeleteCommitment(string userId, long providerId, string hashedCommitmentId, SignInUserModel signinUser)
{
var commitmentId = HashingService.DecodeValue(hashedCommitmentId);
Logger.Info($"Deleting commitment {hashedCommitmentId}", providerId, commitmentId);
await Mediator.Send(new DeleteCommitmentCommand
{
UserId = userId,
ProviderId = providerId,
CommitmentId = commitmentId,
UserDisplayName = signinUser.DisplayName,
UserEmailAddress = signinUser.Email
});
}
public async Task <BulkUploadResultViewModel> UploadFile(string userId, UploadApprenticeshipsViewModel uploadApprenticeshipsViewModel, SignInUserModel signInUser)
{
var commitmentId = HashingService.DecodeValue(uploadApprenticeshipsViewModel.HashedCommitmentId);
var providerId = uploadApprenticeshipsViewModel.ProviderId;
var fileName = uploadApprenticeshipsViewModel.Attachment?.FileName ?? "<unknown>";
var commitment = await GetCommitment(providerId, commitmentId);
AssertCommitmentStatus(commitment);
await AssertAutoReservationEnabled(commitment);
Logger.Info($"Uploading File - Filename:{fileName}", uploadApprenticeshipsViewModel.ProviderId, commitmentId);
var fileValidationResult = await _bulkUploader.ValidateFileStructure(uploadApprenticeshipsViewModel, providerId, commitment);
if (fileValidationResult.Errors.Any())
{
return(new BulkUploadResultViewModel
{
BulkUploadId = fileValidationResult.BulkUploadId,
HasFileLevelErrors = true,
FileLevelErrors = fileValidationResult.Errors
});
}
Logger.Info("Uploading file of apprentices.", providerId, commitmentId);
var rowValidationResult = await _bulkUploader.ValidateFileRows(fileValidationResult.Data, providerId, fileValidationResult.BulkUploadId);
var sw = Stopwatch.StartNew();
var overlapErrors = await GetOverlapErrors(fileValidationResult.Data.ToList());
Logger.Trace($"Validating overlaps took {sw.ElapsedMilliseconds}");
var rowErrors = rowValidationResult.Errors.ToList();
rowErrors.AddRange(overlapErrors);
var hashedBulkUploadId = HashingService.HashValue(fileValidationResult.BulkUploadId);
if (rowErrors.Any())
{
Logger.Info($"{rowErrors.Count} Upload errors", providerId, commitmentId);
return(new BulkUploadResultViewModel
{
BulkUploadId = fileValidationResult.BulkUploadId,
BulkUploadReference = hashedBulkUploadId,
HasRowLevelErrors = true,
RowLevelErrors = rowErrors
});
}
try
{
await Mediator.Send(new BulkUploadApprenticeshipsCommand
{
UserId = userId,
ProviderId = providerId,
CommitmentId = commitmentId,
Apprenticeships = await _mapper.MapFrom(commitmentId, rowValidationResult.Data),
UserEmailAddress = signInUser.Email,
UserDisplayName = signInUser.DisplayName
});
}
catch (Exception)
{
var overlaps = (await GetOverlapErrors(fileValidationResult.Data.ToList())).ToList();
if (overlaps.Any())
{
return(new BulkUploadResultViewModel
{
BulkUploadId = fileValidationResult.BulkUploadId,
HasRowLevelErrors = true,
RowLevelErrors = overlaps
});
}
throw;
}
return(new BulkUploadResultViewModel {
BulkUploadId = fileValidationResult.BulkUploadId
});
}
public async Task <string> CreateCohort(int providerId, ConfirmEmployerViewModel confirmEmployerViewModel, string userId, SignInUserModel signinUser)
{
Logger.Info($"Creating cohort", providerId);
var employerAccountId = _publicHashingService.DecodeValue(confirmEmployerViewModel.EmployerAccountPublicHashedId);
var relationshipData = await Mediator.Send(new GetProviderRelationshipsWithPermissionQueryRequest
{
Permission = Operation.CreateCohort,
ProviderId = providerId
});
//Check that the relationship is a valid selection
var relationship = relationshipData.ProviderRelationships.SingleOrDefault(x =>
x.AccountPublicHashedId == confirmEmployerViewModel.EmployerAccountPublicHashedId &&
x.AccountLegalEntityPublicHashedId == confirmEmployerViewModel.EmployerAccountLegalEntityPublicHashedId
);
if (relationship == null)
{
throw new InvalidOperationException(
$"Error creating cohort - operation not permitted for Provider: {providerId}, Employer Account {employerAccountId}, Legal Entity {confirmEmployerViewModel.EmployerAccountLegalEntityPublicHashedId} ");
}
var providerResponse = await Mediator.Send(new GetProviderQueryRequest { UKPRN = providerId });
var employerAccountHashedId = HashingService.HashValue(employerAccountId);
var accountResponse = await Mediator.Send(new GetEmployerAccountLegalEntitiesRequest
{
UserId = userId,
HashedAccountId = employerAccountHashedId
});
var legalEntity = accountResponse.LegalEntities.SingleOrDefault(x =>
x.AccountLegalEntityPublicHashedId ==
confirmEmployerViewModel.EmployerAccountLegalEntityPublicHashedId);
if (legalEntity == null)
{
throw new InvalidOperationException(
$"Error getting Employer Account Legal entity for {confirmEmployerViewModel.EmployerAccountLegalEntityPublicHashedId}");
}
var createCommitmentRequest = new CreateCommitmentCommand
{
UserId = userId,
Commitment = new Commitment
{
Reference = Guid.NewGuid().ToString().ToUpper(),
EmployerAccountId = employerAccountId,
LegalEntityId = legalEntity.Code,
LegalEntityName = legalEntity.Name,
LegalEntityAddress = legalEntity.RegisteredAddress,
LegalEntityOrganisationType = (OrganisationType)legalEntity.Source,
AccountLegalEntityPublicHashedId = legalEntity.AccountLegalEntityPublicHashedId,
ProviderId = providerId,
ProviderName = providerResponse.ProvidersView.Provider.ProviderName,
CommitmentStatus = CommitmentStatus.New,
EditStatus = EditStatus.ProviderOnly,
ProviderLastUpdateInfo = new LastUpdateInfo {
Name = signinUser.DisplayName, EmailAddress = signinUser.Email
}
}
};
var response = await Mediator.Send(createCommitmentRequest);
return(HashingService.HashValue(response.CommitmentId));
}
public void Arrange()
{
_permissionsResponse = new GetProviderRelationshipsWithPermissionQueryResponse
{
ProviderRelationships = new List <AccountProviderLegalEntityDto>
{
new AccountProviderLegalEntityDto
{
AccountPublicHashedId = _employerAccountPublicHashedId,
AccountId = _employerAccountId,
AccountLegalEntityId = _employerAccountLegalEntityId,
AccountLegalEntityPublicHashedId = _employerAccountLegalEntityPublicHashedId
}
}
};
_hashingService = new Mock <IHashingService>();
_hashingService.Setup(x => x.HashValue(It.Is <long>(l => l == _apiResponse))).Returns("CohortRef");
_publicHashingService = new Mock <IPublicHashingService>();
_publicHashingService.Setup(x => x.DecodeValue(It.Is <string>(s => s == _employerAccountPublicHashedId))).Returns(_employerAccountId);
_publicHashingService.Setup(x => x.DecodeValue(It.Is <string>(s => s == _employerAccountLegalEntityPublicHashedId)))
.Returns(_employerAccountLegalEntityId);
_mediator = new Mock <IMediator>();
_mediator.Setup(x => x.Send(It.IsAny <GetProviderRelationshipsWithPermissionQueryRequest>(),
new CancellationToken()))
.ReturnsAsync(_permissionsResponse);
_provider = new GetProviderQueryResponse
{
ProvidersView = new ProvidersView
{
CreatedDate = new DateTime(2018, 11, 6),
Provider = new Provider
{
ProviderName = "Test Provider"
}
}
};
_mediator.Setup(x => x.Send(It.IsAny <GetProviderQueryRequest>(), It.IsAny <CancellationToken>())).ReturnsAsync(_provider);
_legalEntity = new LegalEntity
{
Id = 1,
AccountLegalEntityPublicHashedId = _employerAccountLegalEntityPublicHashedId,
Code = "code",
Name = "Test Legal Entity",
RegisteredAddress = "Test Address",
Source = 1
};
_mediator.Setup(x =>
x.Send(It.IsAny <GetEmployerAccountLegalEntitiesRequest>(), It.IsAny <CancellationToken>())).ReturnsAsync(
() => new GetEmployerAccountLegalEntitiesResponse
{
LegalEntities = new List <LegalEntity>
{
_legalEntity
}
});
_mediator.Setup(x => x.Send(It.IsAny <CreateCommitmentCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new CreateCommitmentCommandResponse {
CommitmentId = _apiResponse
});
_signInUserModel = new SignInUserModel {
DisplayName = "DisplayName", Email = "*****@*****.**"
};
_confirmEmployerViewModel = new ConfirmEmployerViewModel
{
EmployerAccountLegalEntityPublicHashedId = _employerAccountLegalEntityPublicHashedId,
EmployerAccountPublicHashedId = _employerAccountPublicHashedId
};
_orchestrator = new CreateCohortOrchestrator(_mediator.Object,
_hashingService.Object,
Mock.Of <IProviderCommitmentsLogger>(),
_publicHashingService.Object);
}
public static SignInUser ConvertToSignIn(this SignInUserModel model) => new SignInUser(model.Email, model.Password);
public ActionResult SignIn(SignInUserModel signUser, FormCollection form, string returnUrl)
{
if ( ModelState.IsValid )
{
UserRepository userRepository = new UserRepository();
UserModel user = userRepository.GetByUsername( signUser.Login );
if ( user != null && user.Password == signUser.Password.HashMD5() )
{
if ( user.ActivationCode == null )
{
AuthenticateUser( signUser.Login, signUser.Remember );
if ( !String.IsNullOrEmpty( returnUrl ) )
{
return Redirect( returnUrl );
}
else
{
return RedirectToAction( "Index", "Home" );
}
}
else
{
ViewBag.ErrorMessage = "Your account hasn't been activated yet. " +
"Please visit the activation link from the e-mail message we've sent you.";
return View( signUser );
}
}
else
{
ViewBag.ErrorMessage = "Specified username and/or password is incorrect.";
return View( signUser );
}
}
return View( signUser );
}
public async Task SubmitCommitment(string currentUserId, long providerId, string hashedCommitmentId, SaveStatus saveStatus, string message, SignInUserModel currentUser)
{
var commitmentId = HashingService.DecodeValue(hashedCommitmentId);
await AssertCommitmentStatus(commitmentId, providerId);
Logger.Info($"Submitting ({saveStatus}) Commitment for provider:{providerId} commitment:{commitmentId}", providerId: providerId, commitmentId: commitmentId);
if (saveStatus == SaveStatus.Approve || saveStatus == SaveStatus.ApproveAndSend)
{
var isSigned = await IsSignedAgreement(providerId) == ProviderAgreementStatus.Agreed;
if (!isSigned)
{
throw new InvalidStateException("Cannot approve commitment when no agreement signed");
}
}
LastAction lastAction;
switch (saveStatus)
{
case SaveStatus.AmendAndSend:
lastAction = LastAction.Amend;
break;
case SaveStatus.Approve:
lastAction = LastAction.Approve;
break;
case SaveStatus.ApproveAndSend:
lastAction = LastAction.Approve;
break;
case SaveStatus.Save:
lastAction = LastAction.None;
break;
default:
lastAction = LastAction.None;
break;
}
await
Mediator.Send(
new SubmitCommitmentCommand
{
ProviderId = providerId,
HashedCommitmentId = hashedCommitmentId,
CommitmentId = commitmentId,
Message = message,
LastAction = lastAction,
CreateTask = (saveStatus == SaveStatus.ApproveAndSend || saveStatus == SaveStatus.AmendAndSend),
UserDisplayName = currentUser.DisplayName,
UserEmailAddress = currentUser.Email,
UserId = currentUserId
});
}
public async Task <SignInResult> SignInAsync(SignInUserModel signInUserModel)
{
var result = await _signInManager.PasswordSignInAsync(signInUserModel.Email, signInUserModel.Password, signInUserModel.RememberMe, true);
return(result);
}
public async Task <string> DeleteApprenticeship(string userId, DeleteConfirmationViewModel viewModel, SignInUserModel signinUser)
{
var apprenticeshipId = HashingService.DecodeValue(viewModel.HashedApprenticeshipId);
Logger.Info($"Deleting apprenticeship {apprenticeshipId}", providerId: viewModel.ProviderId, apprenticeshipId: apprenticeshipId);
var apprenticeship = await Mediator.Send(new GetApprenticeshipQueryRequest
{
ProviderId = viewModel.ProviderId,
ApprenticeshipId = apprenticeshipId
});
await Mediator.Send(new DeleteApprenticeshipCommand
{
UserId = userId,
ProviderId = viewModel.ProviderId,
ApprenticeshipId = apprenticeshipId,
UserDisplayName = signinUser.DisplayName,
UserEmailAddress = signinUser.Email
});
return(apprenticeship.Apprenticeship.ApprenticeshipName);
}
//Login
public async Task <SignInResult> PasswordSignInAsync(SignInUserModel signInModel)
{
return(await _signInManager.PasswordSignInAsync(signInModel.Email, signInModel.Password, signInModel.RememberMe, false));
}
