public ActionResult SignUpIndividual(IndividualRegistration individualRegistration)
{
if (!ModelState.IsValid)
{
return(View("SignUpIndividual", individualRegistration));
}
var resourceURI = @"Registration/RegisterIndividual";
UserReturnModel createdUser = null;
try
{
createdUser = this.SendPostRequest <IndividualRegistration, UserReturnModel>(resourceURI, individualRegistration);
PrepareAndSendConfirmationEmail(createdUser.Email, createdUser.Id, createdUser.UserName);
TempData["IsEmailSentSuccessfully"] = true;
return(RedirectToAction("SignUpComplete", "SignUp", new RouteValueDictionary(createdUser)));
}
catch (ApiException ex)
{
return(View("SignUpIndividual", individualRegistration));
}
catch (EmailException emailException)
{
TempData["IsEmailSentSuccessfully"] = false;
return(RedirectToAction("SignUpComplete", "SignUp", new RouteValueDictionary(createdUser)));
}
}
public async Task <IHttpActionResult> UpdateUser(string id, UserReturnModel model)
{
if (id != model.Id)
{
return(BadRequest());
}
var user = await this.AppUserManager.FindByIdAsync(id);
if (user != null)
{
user.ImageUrl = model.ImageUrl;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Description = model.Description;
await this.AssignRolesToUser(user.Id, model.Roles.ToArray());
DB.Entry(user).State = EntityState.Modified;
await this.DB.SaveChangesAsync();
return(Ok(this.TheModelFactory.Create(user)));
}
return(NotFound());
}
public async Task <IHttpActionResult> GetAccessTokenByUserName(GetAccessTokenByUserNameInput input)
{
RestHTTP http = new RestHTTP();
RestSharp.RestRequest req = new RestSharp.RestRequest("/oauth/token", RestSharp.Method.POST);
input.grant_type = "password";
req.AddObject(input);
GetAccessTokenByUserNameOutput output = http.HttpPost <GetAccessTokenByUserNameOutput>(req);
if (output != null && !string.IsNullOrEmpty(output.AccessToken))
{
var user = await this.AppUserManager.FindByNameAsync(input.username);
if (user != null)
{
output.CurrentUserID = user.Id;
output.TwoFactorAuthFlag = user.TwoFactorEnabled;
UserReturnModel userSession = this.TheModelFactory.Create(user);
output.UserSession = new UserReturnModel();
output.UserSession = userSession;
}
}
return(Ok(output));
}
public UserReturnModel UpdateAccount([FromBody] UserReturnModel userData)
{
var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name)
.Select(c => c.Value).SingleOrDefault();
UserReturnModel user = _repo.GetUserById(id);
return(_repo.UpdateAccount(user, userData));
}
public UserReturnModel UpdateAccount([FromBody] UserReturnModel userData)
{
//gets the session id and finds the user where the id matches the ClaimType.Name/id
var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name)
.Select(c => c.Value).SingleOrDefault();
UserReturnModel user = _accountRepo.GetUserById(id);
return(_accountRepo.UpdateAccount(user, userData));
}
public UserAuthorizationInfo CreateUserAuthorizationInfo(UserReturnModel userReturnModel)
{
return(new UserAuthorizationInfo()
{
UserId = userReturnModel.Id,
UserName = userReturnModel.UserName,
Roles = userReturnModel.Roles,
});
}
public string ChangePassword([FromBody] ChangeUserPasswordModel userData)
{
if (ModelState.IsValid)
{
var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name)
.Select(c => c.Value).SingleOrDefault();
UserReturnModel user = _repo.GetUserById(id);
return(_repo.ChangeUserPassword(userData));
}
return("Invalid Creds");
}
public UserReturnModel UpdateAccount([FromBody] UserReturnModel user)
{
var email = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Email).Select(c => c.Value).SingleOrDefault();
var sessionUser = _db.GetUserByEmail(email);
if (sessionUser.Id == user.Id)
{
return(_db.UpdateUser(user));
}
return(null);
}
public ActionResult SignUpPayAndGo(PayAndGoRegistration payNoGoRegistration)
{
_logger.Info("Entered Sign Up Page!");
if (!ModelState.IsValid)
{
return(View("SignUpPayAndGo", payNoGoRegistration));
}
var resourceURI = @"Registration/RegisterIndividual";
UserReturnModel createdUser = null;
_logger.Info(payNoGoRegistration.AgreeToPayandGoConditions);
if (!payNoGoRegistration.AgreeToPayandGoConditions)
{
ModelState.AddModelError("AgreeToPayandGoConditions", "In order to use the pay and go service you must click the agreement checkbox");
return(View("SignUpPayAndGo", payNoGoRegistration));
}
try
{
createdUser = this.SendPostRequest <IndividualRegistration, UserReturnModel>(resourceURI, payNoGoRegistration);
PrepareAndSendConfirmationEmail(createdUser.Email, createdUser.Id, createdUser.UserName);
TempData["IsEmailSentSuccessfully"] = true;
_logger.Debug("PayAndGoAttemptedHere");
#region Pay and Go Specific Stuff
var resourceURI2 = @"Registration/PayAndGoIndividual";
var payAndGoResult = this.SendPostRequest <PayAndGoRegistration, string>(resourceURI2, payNoGoRegistration);
#endregion Pay and Go Specific Stuff
return(RedirectToAction("SignUpComplete", "SignUp", new RouteValueDictionary(createdUser)));
}
catch (ApiException ex)
{
return(View("SignUpIndividual", payNoGoRegistration));
}
catch (EmailException emailException)
{
TempData["IsEmailSentSuccessfully"] = false;
return(RedirectToAction("SignUpComplete", "SignUp", new RouteValueDictionary(createdUser)));
}
}
private UserModel GetUserModeFromUserReturnModel(UserReturnModel user)
{
var userModel = _MasterRepo.DataSource.User;
userModel.UserID = user.userId;
userModel.FirstName = user.firstName;
userModel.LastName = user.lastName;
userModel.MobileNumber = user.mobileNumber;
userModel.IDNumber = user.idNumber;
userModel.BarCode = Convert.FromBase64String(FixBase64ForImage(user.barcode));
return(userModel);
}
public IEnumerable <Vault> GetbyUserID()
{
var user = HttpContext.User;
var id = user.Identity.Name;
UserReturnModel activeUser = null;
if (id != null)
{
activeUser = users.GetUserById(id);
}
var uid = activeUser.Id;
return(db.GetAllByUserId(uid));
}
public UserReturnModel UpdateAccount(UserReturnModel user, UserReturnModel userData)
{
//do more sql
var i = _db.Execute(@"
update users set
email = @Email,
name = @Name
where id = @Id", userData)
if (i > 0)
{
return(userData);
}
return(null);
//or throw an error
}
public VaultKeep Post([FromBody] VaultKeep VaultKeep)
{
var user = HttpContext.User;
var id = user.Identity.Name;
UserReturnModel activeUser = null;
if (id != null)
{
activeUser = userDb.GetUserById(id);
}
VaultKeep.UserId = activeUser.Id;
return(vaultKeepDb.Add(VaultKeep));
}
public IEnumerable <Vault> GetVaultsByActiveUser()
{
var user = HttpContext.User;
var id = user.Identity.Name;
UserReturnModel activeUser = null;
if (id != null)
{
activeUser = userDb.GetUserById(id);
}
var uid = activeUser.Id;
return(vaultDb.GetByUserId(uid));
}
public UserReturnModel UpdateUser(UserReturnModel user)
{
var rowsAffected = _db.Execute(@"
UPDATE users SET
email = @Email,
username = @Username
WHERE id = @id
", user);
if (rowsAffected > 0)
{
return(user);
}
return(null);
}
internal UserReturnModel UpdateAccount(UserReturnModel user, UserReturnModel userData)
{
var i = _db.Execute(@"
UPDATE users SET
email = @Email,
username = @Username
WHERE id = @Id
", userData);
if (i > 0)
{
return(userData);
}
return(null);
}
public async Task <UserReturnModel> Register([FromBody] UserRegisterModel formData)
{
if (ModelState.IsValid)
{
UserReturnModel user = _repo.Register(formData);
if (user != null)
{
ClaimsPrincipal principal = user.SetClaims();
await HttpContext.SignInAsync(principal);
return(user);
}
}
return(null);
}
public async Task <UserReturnModel> Login([FromBody] LoginUserModel creds)
{
if (ModelState.IsValid)
{
UserReturnModel user = _db.Login(creds);
if (user != null)
{
ClaimsPrincipal principal = user.SetClaims();
await HttpContext.SignInAsync(principal);
return(user);
}
}
return(null);
}
public async Task <IHttpActionResult> GetUserSessionByAccessToken(GetUserSessionByAccessTokenInput input)
{
GetAccessTokenByUserNameOutput output = new GetAccessTokenByUserNameOutput();
var user = await this.AppUserManager.FindByNameAsync(input.Username);
if (user != null)
{
output.CurrentUserID = user.Id;
UserReturnModel userSession = this.TheModelFactory.Create(user);
output.UserSession = new UserReturnModel();
output.UserSession = userSession;
}
return(Ok(output));
}
internal UserReturnModel UpdateUser(UserReturnModel user)
{
var i = _db.Execute(@"
UPDATE users SET
email = @Email,
username = @Username
WHERE id = @id
", user);
if (i > 0)
{
return(user);
}
return(null);
}
public Keep Post([FromBody] Keep keep)
{
var user = HttpContext.User;
var id = user.Identity.Name;
UserReturnModel activeUser = null;
if (id != null)
{
activeUser = users.GetUserById(id);
}
var uid = activeUser.Id;
keep.UserId = uid;
return(db.Add(keep));
}
public Vault Post([FromBody] Vault vault)
{
var user = HttpContext.User;
var id = user.Identity.Name;
UserReturnModel activeUser = null;
if (id != null)
{
activeUser = users.GetUserById(id);
}
var uid = activeUser.Id;
vault.Id = uid;
return(db.Add(vault));
}
protected async Task <UserReturnModel> GetCurrentUser()
{
UserReturnModel currentUser = null;
if (User != null)
{
var user = await this.AppUserManager.FindByNameAsync(User.Identity.Name);
if (user != null)
{
currentUser = this.TheModelFactory.Create(user);
}
}
return(currentUser);
}
public UserReturnModel UpdateAccount(UserReturnModel user, UserReturnModel userData)
{
//this only allows the user to update their email and name.
var i = _db.Execute(@"
UPDATE users SET
email = @Email,
name = @Name
WHERE id = @Id
", userData);
if (i > 0)
{
return(user);
}
return(null);
}
public IHttpActionResult GetUserByName(string userName)
{
var user = UnitOfWork.UserRepository.GetByName(userName);
if (user == null)
{
return(NotFound());
}
UserReturnModel uModel = Mapper.Map <User, UserReturnModel>(user);
if (OnlineWorker.IsOnline(user))
{
uModel.Online = true;
}
return(Ok(uModel));
}
public async Task <UserReturnModel> Login([FromBody] UserLoginModel userData)
{
if (!ModelState.IsValid)
{
return(null);
}
try {
UserReturnModel user = _repo.Login(userData);
var principal = user.SetClaims();
await HttpContext.SignInAsync(principal);
return(user);
} catch (Exception e) {
System.Console.WriteLine(e.Message);
}
}
public IEnumerable <Keep> GetKeepsByActiveUser()
{
Console.WriteLine("GetKeepsByActiveUser called!");
var user = HttpContext.User;
var id = user.Identity.Name;
UserReturnModel activeUser = null;
if (id != null)
{
activeUser = userDb.GetUserById(id);
}
var uid = activeUser.Id;
return(keepDb.GetByUserId(uid));
}
public async Task <UserReturnModel> Register([FromBody] UserCreateModel userData)
{
if (ModelState.IsValid)
{
try
{
UserReturnModel user = _repo.Register(userData);
ClaimsPrincipal principal = user.SetClaims();
await HttpContext.SignInAsync(principal);
return(user);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
}
}
return(null);
}
public async Task <UserReturnModel> Login([FromBody] LoginUserModel creds)
{
if (ModelState.IsValid)
{
UserReturnModel user = _db.Login(creds);
if (user != null)
{
var claims = new List <Claim> {
new Claim(ClaimTypes.Email, user.Email)
};
var userIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
await HttpContext.SignInAsync(principal);
return(user);
}
}
return(null);
}
public async Task <UserReturnModel> Register([FromBody] RegisterUserModel creds)
{
// Console.WriteLine("Here it should be");
// Console.WriteLine(creds);
if (ModelState.IsValid)
{
UserReturnModel user = _db.Register(creds);
if (user != null)
{
ClaimsPrincipal principal = user.SetClaims();
await HttpContext.SignInAsync(principal);
return(user);
}
}
// Console.WriteLine("It didnt validate, better figure out why.");
return(null);
}
