public async Task <ActionResult> Upload(HttpPostedFileBase upload)
{
if (ModelState.IsValid)
{
UploadRequestCommand command = new UploadRequestCommand(upload);
Logger.Info($"Processing {upload.FileName}");
Logger.Info(command.ToJson());
UploadRequestResponse response = await Mediator.Send(command);
if (!response.IsValid)
{
ModelState.AddModelError("Upload", response.Message);
return(View());
}
if (response.IsNotFound)
{
return(NotFound());
}
//Map to MVC Models to view using AutoMapper
AccountResponseModel accountResponseModel = Mapper.ToAccountResponseModel(response);
Logger.Info($"Processing {upload.FileName}...Complete");
Logger.Info(accountResponseModel.ToJson());
ViewBag.AscendingParam = true;
return(View(accountResponseModel));
}
LogModelState();
return(View());
}
public IHttpActionResult Register(RegisterRequestModel requestModel)
{
if (ModelState.IsValid)
{
UsernameCommand uniqueUsernameCommand = new UsernameCommand(requestModel.Username);
IEnumerable <ValidationResult> validations = commandDispatcher.Validate(uniqueUsernameCommand);
ModelState.AddModelErrors(validations);
if (ModelState.IsValid)
{
AccountCommand accountCommand = new AccountCommand(requestModel.Username, requestModel.Password);
Account account = commandDispatcher.Dispatch <AccountCommand, Account>(accountCommand);
AuthCommand authCommand = new AuthCommand(account.Id, false);
Authentication authentication = commandDispatcher.Dispatch <AuthCommand, Authentication>(authCommand);
AccountResponseModel responseModel = Mapper
.Map <AccountResponseModel>(authentication)
.Map(account);
return(Ok(responseModel));
}
}
return(BadRequest(ModelState));
}
public IHttpActionResult Login(LoginRequestModel requestModel)
{
if (ModelState.IsValid)
{
AccountCommand accountCommand = Mapper.Map <AccountCommand>(requestModel);
IEnumerable <ValidationResult> validations = commandDispatcher.Validate(accountCommand);
ModelState.AddModelErrors(validations);
if (ModelState.IsValid)
{
AccountByUsernameQuery query = new AccountByUsernameQuery(requestModel.Username);
Account account = queryDispatcher.Dispatch <AccountByUsernameQuery, Account>(query);
AuthCommand loginCommand = new AuthCommand(account.Id, requestModel.RememberMe);
Authentication authentication = commandDispatcher.Dispatch <AuthCommand, Authentication>(loginCommand);
AccountResponseModel responseModel = Mapper
.Map <AccountResponseModel>(authentication)
.Map(account);
return(Ok(responseModel));
}
}
return(BadRequest(ModelState));
}
public JsonResult ForgotPassword(ForgotPasswordViewModel model)
{
var user = UserManager.FindByNameAsync(model.Email);
if (user.Result == null || !(UserManager.IsEmailConfirmed(user.Result.Id)))
{
// Don't reveal that the user does not exist or is not confirmed
// return View("ForgotPasswordConfirmation");
var response1 = new AccountResponseModel
{
Success = false,
Message = "Please confirm your email first. "
};
return(Json(response1, JsonRequestBehavior.AllowGet));
}
string code = UserManager.GeneratePasswordResetToken(user.Result.Id);
var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
UserManager.SendEmailAsync(user.Result.Id, "Reset Password",
"Please reset your password by clicking link: " + callbackUrl);
var response2 = new AccountResponseModel
{
Success = true,
Message = "Password reset link has been sent."
};
return(Json(response2, JsonRequestBehavior.AllowGet));
}
public JsonResult Login(LoginViewModel model)
{
var isSuccess = false;
string message;
if (!ModelState.IsValid)
{
message = "Please use valid credentials ";
}
else
{
var result = SignInManager.PasswordSignIn(model.Email, model.Password, model.RememberMe, true);
switch (result)
{
case SignInStatus.Success:
isSuccess = true;
var dbUser = UserManager.FindByEmail(model.Email);
Session["userFirstName"] = dbUser.FirstName;
Session["timeZoneOfset"] = model.TimeZoonOfset;
message = "Successfully logged in";
break;
case SignInStatus.LockedOut:
message = "Your account has been locked";
break;
case SignInStatus.RequiresVerification:
message = "Account verification required";
break;
default:
message = "Invalid username/password";
break;
}
}
var resposne = new AccountResponseModel
{
Success = isSuccess,
Message = message
};
return(Json(resposne, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> GetAccountsAsync()
{
JsonResult result;
AccountResponseModel response = new AccountResponseModel();
List <Racun> accounts = await _accountFacade.GetAll();
if (accounts == null)
{
response.Message = "Not found! Try again!";
result = new JsonResult(response);
return(NotFound(result));
}
response.Message = "Successfully read accounts!";
response.Accounts = accounts;
result = new JsonResult(response);
return(result);
}
/// </summary>
public Task <AccountResponseModel> GetMyAccount(Guid userUid, Guid customerUid, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetMyAccount)} Mock: userUid {userUid} customerUid {customerUid}");
if (Daves3dDemoCustomerTrn.Contains(customerUid.ToString()))
{
return(Task.FromResult(new AccountResponseModel()
{
TRN = Daves3dDemoCustomerTrn,
Name = "3D Demo customer"
}));
}
var accountResponseModel = new AccountResponseModel
{
TRN = TRNHelper.MakeTRN(customerUid.ToString(), TRNHelper.TRN_ACCOUNT),
Name = "Got this other customer"
};
log.LogDebug($"{nameof(GetMyAccount)} Mock: accountResponseModel {JsonConvert.SerializeObject(accountResponseModel)}");
return(Task.FromResult(accountResponseModel));
}
/// <summary>
/// For a customer master data model, populate customer display model with project information
/// </summary>
private async Task <CustomerDisplayModel> GetAccountModel(AccountResponseModel accountData)
{
var customerModel = new CustomerDisplayModel
{
CustomerName = accountData.Name,
CustomerUid = accountData.Id
};
var headers = CustomHeaders;
// We want to remove any customer UID passed in, and replace it with the customer in question
if (headers.ContainsKey(HeaderConstants.X_VISION_LINK_CUSTOMER_UID))
{
headers.Remove(HeaderConstants.X_VISION_LINK_CUSTOMER_UID);
}
headers.Add(HeaderConstants.X_VISION_LINK_CUSTOMER_UID, accountData.Id);
var projects = await projectProxy.GetProjects(accountData.Id, headers);
customerModel.Projects = await ExecuteAgainstMultiple(projects, y => GetProjectModel(y, headers));
return(customerModel);
}
