public ActionResult Authenticate(UserAccountView account, string returnUrl)
{
var user = _userService.AuthenticateUser(account.Email, account.Password);
if (user.IsAuthenticated)
{
SecurityContextManager.Current.CurrentUser = user.SelectedUser;
SecurityContextManager.Current.IsAuthenticated = true;
SecurityContextManager.Current.CurrentAccessLevel = user.SelectedUser.AccessLevel;
_formsAuthentications.SetAuthenticationToken(user.SelectedUser.ID.ToString());
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
UserAccountView accountView = InitializeAccountViewWithIssue(true, "Invalid credentials. Please try again.");
accountView.CallBackSettings.ReturnUrl = "";
return(View("Index", accountView));
}
}
public ActionResult Edit(string id)
{
UserAccessRepository rep = new UserAccessRepository();
UserAccountView userAccView = new UserAccountView();
userAccView.UserAccount = rep.GetUserAccount(id);
List <Role> roles = rep.GetAllRoles();
userAccView.Roles = new List <SelectListItem>();
foreach (Role role in roles)
{
userAccView.Roles.Add(new SelectListItem {
Text = role.RoleName, Value = role.ID.ToString()
});
}
if (userAccView.UserAccount != null)
{
View("Edit", userAccView);
}
else
{
ViewData["Message"] = "User could not be found!";
}
return(View("Edit", userAccView));
}
public ActionResult ReceiveTokenAndLogon(string token, string returnUrl)
{
IUserAccount user = _externalAuthenticationService.GetUserDetailsFrom(token);
if (user.IsAuthenticated)
{
_formsAuthentications.SetAuthenticationToken(user.AuthenticationToken);
GetUserRequest getUserRequest = new GetUserRequest();
getUserRequest.UserID = user.UserID;
GetUserResponse getUserResponse = _userService.GetUser(getUserRequest);
if (getUserResponse.UserFound)
{
//return RedirectBasedOn(returnUrl);
return(RedirectToAction("Index", "GrowerProfile"));
}
else
{
UserAccountView accountView = InitializeAccountViewWithIssue(true, "Sorry we could not find your user account. If you don't have an account with us please register.");
accountView.CallBackSettings.ReturnUrl = returnUrl;
return(View("Login", accountView));
}
}
else
{
UserAccountView accountView = InitializeAccountViewWithIssue(true, "Sorry we could not log you in. Please try again.");
accountView.CallBackSettings.ReturnUrl = returnUrl;
return(View("Login", accountView));
}
}
public ActionResult Edit(int?userPK)
{
if (userPK != null)
{
IRolesRepository rolesRepository = new RolesRepository(db);
IUsersRepository usersRepository = new UsersRepository(db);
User user = usersRepository.GetUserByUserID((int)userPK);
UserAccountView userAccountView = new UserAccountView();
userAccountView.ConvertFrom(user, userAccountView);
IUsersInRolesRepository usersInRolesRepository = new UsersInRolesRepository(db);
var rolesSelectedValues = usersInRolesRepository.GetRolesByUserPK((int)userPK).Select(uir => uir.RoleFK);
userAccountView.Roles = new MultiSelectList(rolesRepository.GetActiveRoles().ToList(), "RolePK", "Name", rolesSelectedValues);
return(View(userAccountView));
}
else
{
return(RedirectToAction("Index", "User"));
}
}
public ActionResult Edit(UserAccountView UserAccountView, Guid Roles)
{
UserAccessRepository rep = new UserAccessRepository();
List <Role> roles = rep.GetAllRoles();
UserAccountView.Roles = new List <SelectListItem>();
UserAccountView.UserAccount.Role = rep.GetRole(Roles);
ModelState.Remove("Roles"); //We remove any model state error on Roles because we manually load it from the database as drop-down list only returns the selected role
foreach (Role role in roles)
{
UserAccountView.Roles.Add(new SelectListItem {
Text = role.RoleName, Value = role.ID.ToString()
});
}
if (ModelState.IsValid)
{
if (UserAccountView.UserAccount != null)
{
////////////////////
MembershipUser user = Membership.GetUser(UserAccountView.UserAccount.Username);
UserAccount existingAccount = rep.GetUserAccount(UserAccountView.UserAccount.Username);
foreach (AvailableFunction func in existingAccount.Role.AvailableFunctions)
{
System.Web.Security.Roles.RemoveUserFromRole(existingAccount.Username, func.FunctionName);
}
foreach (var func in UserAccountView.UserAccount.Role.AvailableFunctions)
{
System.Web.Security.Roles.AddUserToRole(UserAccountView.UserAccount.Username, func.FunctionName);
}
////////////////////
bool status = rep.UpdateUserAccount(UserAccountView.UserAccount);
if (status)
{
ViewData["Message"] = "User updated successfully!";
}
else
{
ViewData["Message"] = "There was an error updating this user. Please contact your administrator!";
}
return(View("Edit", null));
}
else
{
ViewData["Message"] = "User could not be found!";
}
}
return(View(UserAccountView));
}
public ActionResult Index()
{
UserAccountView view = new UserAccountView();
view.NavView.SelectedMenuItem = "nav-home";
view.Message = "It's Working!!!";
view.CallBackSettings.ReturnUrl = "nav-home";
return(View(view));
}
public ActionResult Add()
{
IRolesRepository rolesRepository = new RolesRepository(db);
UserAccountView userAccountView = new UserAccountView();
userAccountView.Roles = new MultiSelectList(rolesRepository.GetActiveRoles(), "RolePK", "Name");
userAccountView.ChangePassword = true;
return(View(userAccountView));
}
public ActionResult AccountBox()
{
try
{
UserAccountView u = UserAccountViewRepository.GetByUserName(User.Identity.Name);
return(PartialView("_AccountBox", u));
}
catch (MissingResourceException)
{
return(PartialView("_AccountBox"));
}
}
public void CanGetUserByEMail()
{
// Arrange
UserAccountView u1 = UserAccountViewBuilder.BuildUserAccountView();
// Act
UserAccountView u2 = UserAccountViewRepository.GetByEMail(u1.EMail);
// Assert
Assert.IsNotNull(u2);
Assert.AreEqual(u1.Id, u2.Id);
Assert.AreEqual(u1.EMail, u2.EMail);
}
public void CanAddAndGetUser()
{
// Arrange
UserAccountView u1 = UserAccountViewBuilder.BuildUserAccountView("Klaus", "*****@*****.**");
// Act
UserAccountView u2 = UserAccountViewRepository.Get(u1.Id);
// Assert
Assert.IsNotNull(u2);
Assert.AreEqual(u1.Id, u2.Id);
Assert.AreNotEqual(u1.Id, Guid.Empty, "Persistence layer must assign IDs");
Assert.AreEqual(u1.UserName, u2.UserName);
}
public async Task <User> AddUserToWorkspace(UserAccountView newuser, string workspaceName)
{
var workspace = GetWorkspaceByName("dummyWorkspace").Result;
User user = new User()
{
Id = "5b71298a6a2e663634872a34",
UserId = newuser.Id,
FirstName = newuser.FirstName,
LastName = newuser.LastName,
EmailId = newuser.EmailId
};
workspace.Users.Add(user);
return(user);
}
private UserAccountView InitializeAccountViewWithIssue(bool hasIssue, string message)
{
UserAccountView userAccountView = new UserAccountView();
userAccountView.CallBackSettings.Action = "Index";
userAccountView.CallBackSettings.Controller = "Login";
userAccountView.HasIssue = hasIssue;
userAccountView.Message = message;
string returnUrl = _actionArguments
.GetValueForArgument(ActionArgumentKey.ReturnUrl);
userAccountView.CallBackSettings.ReturnUrl = returnUrl;// GetReturnActionFrom(returnUrl).ToString();
return(userAccountView);
}
// Create a new Workspace using workspace view
public async Task <Workspace> CreateWorkspace(WorkspaceView workSpace)
{
Workspace newWorkspace = new Workspace
{
WorkspaceId = workSpace.Id,
WorkspaceName = workSpace.WorkspaceName
};
await _dbWorkSpace.InsertOneAsync(newWorkspace);
//creating default channels in workspace
foreach (var channel in workSpace.Channels)
{
Channel newChannel = new Channel
{
ChannelName = channel.ChannelName,
//Admin = user,
WorkspaceId = newWorkspace.WorkspaceId
};
// newChannel.Users.Add(user);
await CreateDefaultChannel(newChannel, workSpace.WorkspaceName);
}
foreach (var bot in workSpace.Bots)
{
UserAccountView newBot = new UserAccountView
{
EmailId = bot.EmailId,
FirstName = bot.Name,
LastName = "Bot",
Id = bot.Id
};
await AddUserToWorkspace(newBot, workSpace.WorkspaceName);
}
// adding default bot for interspace communication
UserAccountView newUser = new UserAccountView
{
EmailId = "*****@*****.**",
FirstName = "Entre",
LastName = "Bot",
Id = "60681125-e117-4bb2-9287-eb840c4cg672"
};
await AddUserToWorkspace(newUser, workSpace.WorkspaceName);
return(await GetWorkspaceById(newWorkspace.WorkspaceId));
}
public void WhenGettingUserByEMailItIgnoresCasing()
{
// Arrange
UserAccountView u1 = UserAccountViewBuilder.BuildUserAccountView();
// Act
UserAccountView u2 = UserAccountViewRepository.GetByEMail(u1.EMail.ToLower());
UserAccountView u3 = UserAccountViewRepository.GetByEMail(u1.EMail.ToUpper());
// Assert
Assert.IsNotNull(u2);
Assert.AreEqual(u1.Id, u2.Id);
Assert.AreEqual(u1.EMail, u2.EMail);
Assert.IsNotNull(u3);
Assert.AreEqual(u1.Id, u3.Id);
Assert.AreEqual(u1.EMail, u3.EMail);
}
public ActionResult Index()
{
IUsersRepository usersRepository = new UsersRepository(db);
int page = !String.IsNullOrWhiteSpace(Request.QueryString["page"]) ? Convert.ToInt32(Request.QueryString["page"]) : 1;
int pageSize = !String.IsNullOrWhiteSpace(Request.QueryString["pageSize"]) ? Convert.ToInt32(Request.QueryString["pageSize"]) : Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["ResultsPerPage"]);
string sortOrder = !String.IsNullOrWhiteSpace(Request.QueryString["sortOrder"]) ? Request.QueryString["sortOrder"] : "DESC";
string sortColumn = !String.IsNullOrWhiteSpace(Request.QueryString["sortColumn"]) ? Request.QueryString["sortColumn"] : "UserPK";
string ordering = sortColumn + " " + sortOrder;
ordering = ordering.Trim();
IQueryable <UserAccountView> users = UserAccountView.GetUserAccountView(usersRepository.GetValid())
.OrderBy(ordering);
if (!String.IsNullOrWhiteSpace(Request.QueryString["searchString"]))
{
string searchString = Request.QueryString["searchString"].ToString();
users = users.Where(c => c.Username.Contains(searchString) || c.FirstName.Contains(searchString) || c.LastName.Contains(searchString));
}
ViewData["numberOfRecords"] = users.Count();
users = users.Page(page, pageSize);
int numberOfPages = ((int)ViewData["numberOfRecords"] + pageSize - 1) / pageSize;
if (page > numberOfPages)
{
string url = LinkHelper.getQueryStringArray(new string[] { "page" });
return(Redirect("User?" + url + "page=" + numberOfPages));
}
else
{
return(View("Index", users.ToList()));
}
}
public ActionResult Create(string message)
{
UserAccessRepository rep = new UserAccessRepository();
UserAccountView userAccView = new UserAccountView();
List <Role> roles = rep.GetAllRoles();
userAccView.Roles = new List <SelectListItem>();
userAccView.ExistingUserAccounts = rep.GetUserAccounts();
foreach (Role role in roles)
{
userAccView.Roles.Add(new SelectListItem {
Text = role.RoleName, Value = role.ID.ToString()
});
}
if (message != null)
{
ViewData["Message"] = message;
}
return(View(userAccView));
}
public IActionResult AddUserToWorkspace([FromBody] UserAccountView user, string workspaceName) // frombody workspace object or string name
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
// get the workspace in which user needs to be added
var searchedWorkSpace = iservice.GetWorkspaceByName(workspaceName).Result;
// check if user already added in workspace
var userAlreadyInWorkspace = searchedWorkSpace.Users.Find(u => u.UserId == user.Id);
if (userAlreadyInWorkspace != null)
{
// return error message if already added
return(NotFound("User already added in Workspace"));
}
}
catch { }
// call service to add user to workspace
var userAdded = iservice.AddUserToWorkspace(user, workspaceName).Result;
return(new ObjectResult(userAdded));
}
public ActionResult IndexPost(UserAccountView model)
{
if (ModelState.IsValid)
{
var entity = _unitOfWork.UserRepository.Table().FirstOrDefault(x => x.LoginName == model.LoginName);
if (entity != null)
{
//entity.LoginPwd = AccountService.ConvertPwd(entity.LoginPwd);
if (entity.LoginPwd == model.LoginPwd)
{
SuccessNotification("登录成功");
HttpCookie cookie_Account = new HttpCookie("Account", entity.LoginName);
Response.AppendCookie(cookie_Account);
return(RedirectToAction("Index", "Home"));
}
ErrorNotification("密码错误!");
return(View(model));
}
ErrorNotification("登录名错误!");
return(View(model));
}
ErrorNotification("表单不能为空，请认真填写！");
return(View(model));
}
public ActionResult Add(UserAccountView userAccountView, FormCollection form)
{
IUsersRepository usersRepository = new UsersRepository(db);
if (userAccountView.Username != null)
{
if (usersRepository.GetUserByUsername(userAccountView.Username) != null)
{
ModelState.AddModelError("Username", "Korisničko ime već postoji.");
}
}
if (userAccountView.Email != null)
{
if (usersRepository.GetUserByEmail(userAccountView.Email) != null)
{
ModelState.AddModelError("Email", "E-mail već postoji.");
}
}
if (ModelState.IsValid)
{
string sessionToken = Audit.GenerateNewSessionToken();
User user = new User();
userAccountView.RegistrationDate = DateTime.Now;
PBKDF2 pbkdf2 = new PBKDF2(userAccountView.Password);
var passwordBytes = pbkdf2.ComputePBKDF2();
userAccountView.Password = Convert.ToBase64String(passwordBytes);
userAccountView.Salt = Convert.ToBase64String(pbkdf2.SaltBytes);
string[] rolesSelectedValues = new string[100];
if (form["RolePK"] != null)
{
rolesSelectedValues = ((string)form["RolePK"]).Split(',');
}
userAccountView.ConvertTo(userAccountView, user);
usersRepository.Add(user);
usersRepository.SaveChanges(sessionToken);
// Delete old roles
IUsersInRolesRepository usersInRolesRepository = new UsersInRolesRepository(db);
usersInRolesRepository.Delete(uir => uir.UserFK == user.UserPK);
// Add New Roles
foreach (string role in rolesSelectedValues)
{
UserInRole tmpUserInRole = new UserInRole();
tmpUserInRole.UserFK = user.UserPK;
tmpUserInRole.RoleFK = Convert.ToInt32(role);
usersInRolesRepository.Add(tmpUserInRole);
}
usersInRolesRepository.SaveChanges(sessionToken);
TempData["message"] = LayoutHelper.GetMessage("INSERT", user.UserPK);
return(RedirectToAction("Index", "User"));
}
else
{
string[] rolesSelectedValues = new string[100];
if (form["RolePK"] != null)
{
rolesSelectedValues = ((string)form["RolePK"]).Split(',');
}
IRolesRepository rolesRepository = new RolesRepository(db);
userAccountView.Roles = new MultiSelectList(rolesRepository.GetActiveRoles(), "RolePK", "Name", rolesSelectedValues);
return(View(userAccountView));
}
}
public ActionResult RegisterUnknownExternal(RegisterUnknownExternalModel model)
{
string provider = null;
string providerUserId = null;
if (User.Identity.IsAuthenticated || !OAuthWebSecurity.TryDeserializeProviderUserId(model.ExternalLoginData, out provider, out providerUserId))
{
return(RedirectToHome());
}
model.ProviderName = provider;
model.ProviderUserId = providerUserId;
model.EMail = model.ProviderEMail;
if (!string.IsNullOrEmpty(model.IsRedirect))
{
ModelState.Clear();
return(View(model));
}
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
OAuthWebSecurity.CreateOrUpdateAccount(provider, providerUserId, model.UserName);
UserAccountView user = UserAccountViewRepository.GetByUserName(model.UserName);
//if (!string.IsNullOrEmpty(model.Password))
// user.ChangePassword(model.Password, Chimera.Authentication.Shared.UserAccounts.Configuration.Settings.GetPasswordPolicy());
//if (!string.IsNullOrEmpty(model.EMail))
// user.ChangeEMail(model.EMail);
//UserRepository.Update(user);
OAuthWebSecurity.Login(provider, providerUserId, createPersistentCookie: false);
return(Configuration.Settings.RegisterSuccessUrl.Redirect());
}
catch (DuplicateKeyException ex)
{
if (ex.Key == "UserName")
{
ModelState.AddModelError("", "User name is already in use");
}
else if (ex.Key == "EMail")
{
ModelState.AddModelError("", "EMail is already in use");
}
else if (ex.Key == "ExternalLogin")
{
ModelState.AddModelError("", "External login is already in use");
}
else
{
ModelState.AddModelError("", "Unknown error");
}
}
catch (InvalidUserNameException)
{
ModelState.AddModelError("UserName", _.AuthWeb.InvalidUserName);
}
catch (MembershipCreateUserException ex)
{
ModelState.AddModelError("", ErrorCodeToString(ex.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Index()
{
UserAccountView accountView = InitializeAccountViewWithIssue(false, "");
return(View(accountView));
}
public ActionResult Create(UserAccount UserAccount, Guid Roles)
{
UserAccessRepository rep = new UserAccessRepository();
if (ModelState.IsValid)
{
UserAccount.Role = rep.GetRole(Roles);
UserAccount.Person.Address.Country = "Canada";
UserAccount.Person.Organization = new Organization(Guid.Parse(ConfigurationManager.AppSettings["HostingOrganizationID"].ToString()));
MembershipCreateStatus createStatus;
MembershipUser newUser = Membership.CreateUser(UserAccount.Username, UserAccount.Password, UserAccount.Person.Email, "Q", "P", true, out createStatus);
UserAccount.Person.Type = PersonType.Employee;
switch (createStatus)
{
case MembershipCreateStatus.DuplicateUserName:
ViewData["Message"] = "Duplicate username! This username already exists in the system.";
break;
case MembershipCreateStatus.InvalidPassword:
ViewData["Message"] = "Invalid password! Minimum password length is six characters.";
break;
case MembershipCreateStatus.Success:
foreach (AvailableFunction func in UserAccount.Role.AvailableFunctions)
{
System.Web.Security.Roles.AddUserToRole(UserAccount.Username, func.FunctionName);
}
if (rep.CreateUserAccount(UserAccount))
{
ViewData["Message"] = "User account created succesfully!";
UserAccount = null;
ModelState.Clear(); //Will clear out the form
return(RedirectToAction("Create", "UserAccount", new { message = "User account created succesfully!" }));
}
else
{
ViewData["Message"] = "There was an error creating this user. Please contact your administrator.";
}
break;
default:
ViewData["Message"] = "There was an error creating this user. Please contact your administrator.";
break;
}
}
UserAccountView userAccView = new UserAccountView();
List <Role> roles = rep.GetAllRoles();
userAccView.Roles = new List <SelectListItem>();
foreach (Role role in roles)
{
userAccView.Roles.Add(new SelectListItem {
Text = role.RoleName, Value = role.ID.ToString()
});
}
userAccView.ExistingUserAccounts = rep.GetUserAccounts();
userAccView.UserAccount = UserAccount;
return(View("Create", userAccView));
}
// add user to workspace
public async Task <User> AddUserToWorkspace(UserAccountView newuser, string workspaceName)
{
// make a user object from user account view
User user = new User
{
UserId = newuser.Id,
EmailId = newuser.EmailId,
FirstName = newuser.FirstName,
LastName = newuser.LastName
};
//insert a new document in mongo collection of user
await _dbUser.InsertOneAsync(user);
// get workspace by name
var resultWorkspace = GetWorkspaceByName(workspaceName).Result;
// add user to workspace
resultWorkspace.Users.Add(user);
// filter to update workpsace in monog collection
var filterWorkspace = new FilterDefinitionBuilder <Workspace>().Where(r => r.WorkspaceId == resultWorkspace.WorkspaceId);
//update definition for workspace
var updateWorkspace = Builders <Workspace> .Update
.Set(r => r.Users, resultWorkspace.Users)
.Set(r => r.WorkspaceId, resultWorkspace.WorkspaceId);
// update in mongo collection
await _dbWorkSpace.UpdateOneAsync(filterWorkspace, updateWorkspace);
// get list of default channel names given by user
var listOfDefaultChannels = resultWorkspace.DefaultChannels;
//make a new list of channels of channel state
List <ChannelState> listOfDefaultChannelState = new List <ChannelState>();
foreach (var defaultChannel in listOfDefaultChannels)
{
await AddUserToDefaultChannel(user, defaultChannel.ChannelId);
ChannelState channel = new ChannelState()
{
channelId = defaultChannel.ChannelId,
UnreadMessageCount = 0,
};
// add it to the list of default channels
listOfDefaultChannelState.Add(channel);
}
// get redis database and call it cache
var cache = RedisConnectorHelper.Connection.GetDatabase();
// CHECK THESE COMMENTED LINES ONCE AGAIN !!!!!!!!!!!!!!!!
//string jsonString = JsonConvert.SerializeObject(resultWorkspace);
//await cache.StringSetAsync($"{resultWorkspace.WorkspaceName}", jsonString);
///////////////Notification Work/////////////////////
//get user state by email of new user
var userstate = await GetUserStateByEmailId(user.EmailId);
// add workspace state to user state if user state already exists
if (userstate != null)
{
WorkspaceState newWorkspace = new WorkspaceState()
{
WorkspaceName = workspaceName,
};
foreach (var channel in listOfDefaultChannelState)
{
newWorkspace.ListOfChannelState.Add(channel);
}
userstate.ListOfWorkspaceState.Add(newWorkspace);
// update in cache
string jsonStringUserState = JsonConvert.SerializeObject(userstate);
await cache.StringSetAsync($"{userstate.EmailId}", jsonStringUserState);
}
//else create a new user state
else
{
WorkspaceState newWorkspace = new WorkspaceState()
{
WorkspaceName = workspaceName,
};
foreach (var channel in listOfDefaultChannelState)
{
newWorkspace.ListOfChannelState.Add(channel);
}
UserState newUserState = new UserState()
{
EmailId = user.EmailId,
};
newUserState.ListOfWorkspaceState.Add(newWorkspace);
// create a mongo document
await CreateNotificationStateOfUser(newUserState);
// add it in cache
string jsonStringUserState = JsonConvert.SerializeObject(newUserState);
await cache.StringSetAsync($"{newUserState.EmailId}", jsonStringUserState);
}
////////////////////////////////////////////////////////
return(user);
}
public ActionResult Index(UserAccountView model)
{
return(View(model));
}
