public MembershipCreateStatus CreateUser(string userName, string password, string email, string role)
{
if (String.IsNullOrEmpty(userName))
{
throw new ArgumentException("Value cannot be null or empty.", "userName");
}
if (String.IsNullOrEmpty(password))
{
throw new ArgumentException("Value cannot be null or empty.", "password");
}
if (String.IsNullOrEmpty(email))
{
throw new ArgumentException("Value cannot be null or empty.", "email");
}
MembershipCreateStatus status;
_provider.CreateUser(userName, password, email, null, null, true, null, out status);
if (status == MembershipCreateStatus.Success)
{
string[] users = { userName };
string[] roles = { role };
ResetRoles(userName);
_roleProvider.AddUsersToRoles(users, roles);
}
return(status);
}
public void AddUserToRole(string username, string role)
{
var roles = _provider.GetAllRoles();
_provider.RemoveUsersFromRoles(new string[] { username }, roles);
_provider.AddUsersToRoles(new string[] { username }, new string[] { role });
}
private MembershipCreateStatus?ObtainUser(string username, string roleName)
{
if (_membershipProvider.GetUser(username, false) != null)
{
if (!_roleProvider.IsUserInRole(username, roleName))
{
_roleProvider.AddUsersToRoles(new[] { username }, new[] { roleName });
}
return(null);
}
var status = ObtainUser(username);
_roleProvider.AddUsersToRoles(new[] { username }, new[] { roleName });
return(status);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
if (!Initialized)
{
_prevProvider.AddUsersToRoles(usernames, roleNames);
}
else
{
if (usernames.Where(username => string.IsNullOrEmpty(username)).Count() > 0 || usernames.Where(username => string.IsNullOrEmpty(username)).Count() > 0)
{
throw new ArgumentException(Resources.InvalidArrayValue);
}
using (MySqlDatabaseWrapper dbConn = new MySqlDatabaseWrapper(ConnectionString))
{
foreach (var userid in GetUsersId(usernames))
{
foreach (var roleid in GetRolesId(roleNames))
{
if (userid > 0 && roleid > 0)
{
dbConn.ExecuteNonQuery(string.Format("insert into {0} (userid, roleid) values(?,?);", _userInRolesTable), userid, roleid);
}
}
}
}
}
}
public void AssignSpecialRoleToSpecialUserTest()
{
if (!rp.RoleExists(specialRN))
{
CreateSpecialRoleTest();
}
rp.AddUsersToRoles(new[] { specialUN }, new[] { specialRN });
Assert.IsTrue(rp.IsUserInRole(specialUN, specialRN));
TakeAwayFromSpecialUserTest();
}
public void Can_Add_Users_To_Role()
{
var user = new User {Username = "******", Password="******"};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new [] { "sallen"}, new [] { "admin"});
Assert.True(_db.UserIsInRole("sallen", "admin"));
}
public void Can_Throw_When_Users_In_Role()
{
var user = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin" });
Assert.Throws <ProviderException>(() => RoleProvider.DeleteRole("admin", true));
}
public void AddUsersToRoles(string[] userNames, string[] roleNames)
{
if (userNames.Count() <= 0)
{
throw new ArgumentException("Value cannot be null or empty.", "userNames");
}
if (roleNames.Count() <= 0)
{
throw new ArgumentException("Value cannot be null or empty.", "roleNames");
}
_provider.AddUsersToRoles(userNames, roleNames);
}
public void Can_Add_Users_To_Role()
{
var user = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin" });
Assert.True(Verifier.Query <Role>().SingleOrDefault(r => r.Name == "admin").Users.Contains("sallen"));
}
public void Doesnt_Find_User_Not_In_Role()
{
var user = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin" });
Assert.False(RoleProvider.IsUserInRole("sallen", "sales"));
}
public void Can_Delete_Role_With_Users()
{
var user = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin" });
RoleProvider.DeleteRole("admin", false);
Assert.False(Verifier.Query <Role>().Any(r => r.Name == "admin"));
}
public void Can_Delete_Role_With_Users()
{
var user = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
MembershipProvider.CreateAccount(user);
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin" });
RoleProvider.DeleteRole("admin", false);
Assert.False(_db.CanFindRole("admin"));
}
public static string[] WithUserInRoles(this RoleProvider roleProvider, string userName, params string[] roles)
{
roles.ToList().ForEach(
x =>
{
if (!roleProvider.RoleExists(x))
{
roleProvider.CreateRole(x);
}
roleProvider.AddUsersToRoles(new[] { userName }, new[] { x });
});
return(roles);
}
public ActionResult JsonRegister(string username, string password)
{
if (ModelState.IsValid)
{
var objUser = Membership.GetUser(username);
if (objUser != null)
{
ModelState.AddModelError("", "The email address is already registered in the system. Please try again.");
return(Json(new { errors = GetErrorsFromModelState(), status = "error" }));
}
else
{
// Attempt to register the user
MembershipCreateStatus createStatus;
System.Web.Security.Membership.CreateUser(username, password, username, passwordQuestion: null, passwordAnswer: null, isApproved: false, providerUserKey: null, status: out createStatus);
if (createStatus == MembershipCreateStatus.Success)
{
//FormsAuthentication.SetAuthCookie(username, createPersistentCookie: false);
string link = this.RegistrationConfirmationLink(username);
EmailSender.RegistrationConfirmationEmail(email: username, activationLink: link);
RoleProvider objRoleProvider = Roles.Providers["DefaultRoleProvider"];
string[] arrUsername = new string[1] {
username
};
string[] arrRole = new string[1] {
"Leonni User"
};
objRoleProvider.AddUsersToRoles(arrUsername, arrRole);
return(Json(new { success = true }));
//@sujesh
//Do not login the user here, just display a message to check his email and click on that link.
}
else
{
ModelState.AddModelError("", ErrorCodeToString(createStatus));
}
return(Json(new { errors = GetErrorsFromModelState(), status = "success" }));
}
}
// If we got this far, something failed
return(Json(new { errors = GetErrorsFromModelState(), status = "error" }));
}
public void Can_Get_Roles_For_User()
{
var user = new User {
Username = "******", Password = "******"
};
MembershipProvider.CreateAccount(user);
RoleProvider.CreateRole("admin");
RoleProvider.CreateRole("sales");
RoleProvider.CreateRole("engineering");
RoleProvider.AddUsersToRoles(new[] { "sallen" }, new[] { "admin", "engineering" });
Assert.True(RoleProvider.GetRolesForUser("sallen").Length == 2);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
LogDebug("Entering CachedProvider.AddUsersToRoles");
foreach (string username in usernames)
{
if (_cache.ContainsKey(username))
{
foreach (string roleName in roleNames)
{
List <string> roles = (List <string>)_cache[username];
if (!roles.Contains(roleName))
{
roles.Add(roleName);
}
}
}
}
_provider.AddUsersToRoles(usernames, roleNames);
}
public void UpdateUser(MembershipUser user, string[] roles)
{
using (var ts = new TransactionScope())
{
_provider.UpdateUser(user);
var existingRoles = _roleProvider.GetRolesForUser(user.UserName);
if (roles != null && roles.Length > 0)
{
var rolesToBeAdded = roles.Except(existingRoles).ToArray();
_roleProvider.AddUsersToRoles(new[] { user.UserName }, rolesToBeAdded);
}
if (existingRoles.Length > 0)
{
var rolesToBeDeleted = (roles != null ? existingRoles.Except(roles) : existingRoles).ToArray();
_roleProvider.RemoveUsersFromRoles(new[] { user.UserName }, rolesToBeDeleted);
}
ts.Complete();
}
}
public void Can_Get_Users_In_Role()
{
var user1 = new User {
Username = "******", Password = "******"
};
var user2 = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
RoleProvider.CreateRole("engineering");
RoleProvider.CreateRole("sales");
MembershipProvider.CreateAccount(user1);
MembershipProvider.CreateAccount(user2);
RoleProvider.AddUsersToRoles(new[] { "sallen", "missmm" }, new[] { "admin", "engineering" });
Assert.Equal(2, RoleProvider.GetUsersInRole("admin").Length);
}
public void Can_Remove_Users_From_Roles()
{
var user1 = new User {
Username = "******", Password = "******"
};
var user2 = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
RoleProvider.CreateRole("engineering");
RoleProvider.CreateRole("sales");
MembershipProvider.CreateAccount(user1);
MembershipProvider.CreateAccount(user2);
RoleProvider.AddUsersToRoles(new[] { "sallen", "missmm" }, new[] { "admin", "engineering" });
RoleProvider.RemoveUsersFromRoles(new[] { "sallen", "missmm" }, new[] { "sales", "admin" });
Assert.True(RoleProvider.IsUserInRole("sallen", "engineering"));
Assert.False(RoleProvider.IsUserInRole("sallen", "admin"));
}
//ADD
public void AddUsersToRoles(string[] usernames, string[] rolenames)
{
_provider.AddUsersToRoles(usernames, rolenames);
}
/// <summary>
/// Adds to role.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="roleName">Name of the role.</param>
public void AddToRole(MembershipUser user, string roleName)
{
_roleProvider.AddUsersToRoles(new[] { user.UserName }, new[] { roleName });
}
public ActionResult EditPlace(Place place, HttpPostedFileBase Logo, HttpPostedFileBase Image, FormCollection collection)
{
if (collection["Save"].IsFilled())
{
bool needCreateModer = false;
place.IsPost = true;
if (/*Logo == null || Logo.ContentLength == 0 || Image == null || Image.ContentLength == 0 ||*/
place.Name.IsNullOrEmpty() || place.Adress.IsNullOrEmpty() || place.Description.IsNullOrEmpty() ||
!place.MinPay.HasValue || !place.MaxPay.HasValue ||
place.Type.IsNullOrEmpty() || (place.WishToBeAdmin && !place.AdminMail.IsMailAdress()))
{
return(View(place));
}
if (place.ID > 0)
{
var p = DB.Places.First(x => x.ID == place.ID);
needCreateModer = p.AdminMail != place.AdminMail && place.AdminMail.IsMailAdress() && place.WishToBeAdmin;
p.LoadPossibleProperties(place, new[] { "Logo", "Approved" });
place = p;
if (!needCreateModer)
{
place.AdminMail = "";
}
}
if (!(Logo == null || Logo.ContentLength == 0))
{
string fileNameLogo = Guid.NewGuid() + Path.GetExtension(Logo.FileName);
string pathLogo = "/Content/Places/" + fileNameLogo;
Logo.SaveAs(Server.MapPath(pathLogo));
place.Logo = pathLogo;
}
if (!(Image == null || Image.ContentLength == 0))
{
string fileNameImage = Guid.NewGuid() + Path.GetExtension(Image.FileName);
string pathImage = "/Content/Places/" + fileNameImage;
Image.SaveAs(Server.MapPath(pathImage));
DB.PlaceImages.InsertOnSubmit(new PlaceImage()
{
Path = pathImage, Place = place
});
}
var isNew = false;
if (place.ID == 0)
{
isNew = true;
needCreateModer = place.AdminMail.IsMailAdress() && place.WishToBeAdmin;
DB.Places.InsertOnSubmit(place);
}
if (needCreateModer)
{
var u = DB.Users.FirstOrDefault(x => x.Email.ToLower().Trim() == place.AdminMail.ToLower().Trim());
if (u == null)
{
var dict = new Dictionary <string, object>();
var pass = new Random(DateTime.Now.Millisecond).GeneratePassword();
dict.Add("UserName", place.AdminMail);
dict.Add("Email", place.AdminMail);
MembershipProvider.CreateUserAndAccount(place.AdminMail, pass, false, dict);
RoleProvider.AddUsersToRoles(new[] { place.AdminMail }, new[] { "Client", "Moderator" });
NotifyMail.SendNotify("PlaceAdminCreate", place.AdminMail,
format => string.Format(format, HostName),
format => string.Format(format, place.AdminMail, pass, HostName)
);
u = DB.Users.First(x => x.Email.ToLower().Trim() == place.AdminMail.ToLower().Trim());
var exist = DB.PlaceAdmins.FirstOrDefault(x => x.PlaceID == place.ID && x.UserID == u.ID);
if (exist == null)
{
exist = new PlaceAdmin()
{
PlaceID = place.ID, UserID = u.ID
};
DB.PlaceAdmins.InsertOnSubmit(exist);
}
}
else
{
NotifyMail.SendNotify("PlaceAdminExist", place.AdminMail,
format => string.Format(format, HostName),
format => string.Format(format, "", "", HostName)
);
if (u.webpages_UsersInRoles.All(x => x.webpages_Role.RoleName != "Moderator"))
{
RoleProvider.AddUsersToRoles(new[] { u.Name }, new[] { "Moderator" });
}
var exist = DB.PlaceAdmins.FirstOrDefault(x => x.PlaceID == place.ID && x.UserID == u.ID);
if (exist == null)
{
exist = new PlaceAdmin()
{
PlaceID = place.ID, UserID = u.ID
};
DB.PlaceAdmins.InsertOnSubmit(exist);
}
}
}
else if (place.PlaceAdmins.Any())
{
DB.PlaceAdmins.DeleteAllOnSubmit(place.PlaceAdmins);
}
DB.SubmitChanges();
return(isNew ? RedirectToAction("Places") : RedirectToAction("EditPlace", new { ID = place.ID, FromSave = 1 }));
}
else
{
if (place.ID == 0)
{
return(RedirectToAction("Places"));
}
var p = DB.Places.First(x => x.ID == place.ID);
if (!p.Approved)
{
p.Approved = true;
if (p.AdminMail.IsMailAdress())
{
var user = DB.Users.FirstOrDefault(x => x.Email.ToLower().Trim() == p.AdminMail.ToLower().Trim());
if (user == null)
{
var dict = new Dictionary <string, object>();
var pass = new Random(DateTime.Now.Millisecond).GeneratePassword();
dict.Add("UserName", p.AdminMail);
dict.Add("Email", p.AdminMail);
MembershipProvider.CreateUserAndAccount(p.AdminMail, pass, false, dict);
RoleProvider.AddUsersToRoles(new[] { p.AdminMail }, new[] { "Client", "Moderator" });
NotifyMail.SendNotify("PlaceAdminCreate", p.AdminMail,
format => string.Format(format, HostName),
format => string.Format(format, p.AdminMail, pass, HostName)
);
user = DB.Users.First(x => x.Email.ToLower().Trim() == p.AdminMail.ToLower().Trim());
var exist = DB.PlaceAdmins.FirstOrDefault(x => x.PlaceID == p.ID && x.UserID == user.ID);
if (exist == null)
{
exist = new PlaceAdmin()
{
PlaceID = p.ID, UserID = user.ID
};
DB.PlaceAdmins.InsertOnSubmit(exist);
}
}
else
{
NotifyMail.SendNotify("PlaceAdminExist", p.AdminMail,
format => string.Format(format, HostName),
format => string.Format(format, "", "", HostName)
);
if (user.webpages_UsersInRoles.All(x => x.webpages_Role.RoleName != "Moderator"))
{
RoleProvider.AddUsersToRoles(new[] { user.Name }, new[] { "Moderator" });
}
var exist = DB.PlaceAdmins.FirstOrDefault(x => x.PlaceID == p.ID && x.UserID == user.ID);
if (exist == null)
{
exist = new PlaceAdmin()
{
PlaceID = p.ID, UserID = user.ID
};
DB.PlaceAdmins.InsertOnSubmit(exist);
}
}
}
}
else
{
p.Approved = false;
if (p.AdminMail.IsMailAdress())
{
NotifyMail.SendNotify("PlaceAdminBlock", p.AdminMail,
format => string.Format(format, HostName),
format => string.Format(format, "", "", HostName, p.Name)
);
}
}
DB.SubmitChanges();
return(RedirectToAction("Places"));
}
}
public void AddUserToRole(string username, string roleName)
{
_provider.AddUsersToRoles(new string[] { username }, new string[] { roleName });
}
public ActionResult RegBlockPartner(RegisterModelPartnerStep1 model)
{
model.IsPost = true;
if (!model.Agree || model.Name.IsNullOrEmpty() || model.Surname.IsNullOrEmpty() || !model.Email.IsMailAdress() || model.Phone.IsNullOrEmpty())
{
return(PartialView(model));
}
var rand = new Random(DateTime.Now.Millisecond);
var pass = rand.GeneratePassword();
string digitID = "";
for (int i = 0; i < 500; i++)
{
var digit = rand.Next(100000000, 999999999);
if (!DB.Users.Any(x => x.DigitID == digit.ToString()))
{
digitID = digit.ToString();
break;
}
}
var confirmKey = Guid.NewGuid();
string link = Url.Action("CheckKey", "Home", new { key = confirmKey });
var message = NotifyMail.SendNotify("Register", model.Email,
format => string.Format(format, HostName),
format => string.Format(format, HostName, link)
);
if (message.IsNullOrEmpty())
{
var dict = new Dictionary <string, object>();
dict.Add("UserName", model.Name);
dict.Add("UserSurname", model.Surname);
dict.Add("Email", model.Email);
dict.Add("UserPatrinomic", model.Patrinomic);
dict.Add("Phone", model.Phone);
dict.Add("RegStep", 1);
dict.Add("IsPhoneConfirmed", false);
dict.Add("DigitID", digitID);
dict.Add("ConfirmKey", confirmKey);
try
{
MembershipProvider.CreateUserAndAccount(model.Email, pass, false, dict);
}
catch
{
model.Email = "";
model.Message = "Пользователь с таким E-mail уже зарегистрирован.";
return(PartialView(model));
}
RoleProvider.AddUsersToRoles(new[] { model.Email }, new[] { "ShopOwner" });
var user = DB.Users.FirstOrDefault(x => x.Email == model.Email);
if (user != null)
{
Logger.WriteEvent(Logger.EventType.UserRegister, "Регистрация в системе", user.ID);
}
model.Message =
"На указанный Вами электронный адрес было выслано письмо<br>Пожалуйста, перейдите по ссылке из письма для продолжения регистрации в системе";
}
else
{
model.Message = message;
}
return(PartialView(model));
}
public void AddUserToRoles(MembershipUser user, string[] roles)
{
_roleProvider.AddUsersToRoles(new string[] { user.UserName }, roles);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
RoleProvider.AddUsersToRoles(usernames, roleNames);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
RoleProvider rp = Roles.Providers["SqlRoleProvider"];
rp.AddUsersToRoles(usernames, roleNames);
}
public static void AddUserToRole(this RoleProvider roleProvider, string userName, string role)
{
roleProvider.AddUsersToRoles(new[] { userName }, new[] { role });
}
private static void addUserToRole(UserCreateStub user, string roleName, RoleProvider provider)
{
provider.AddUsersToRoles(new string[] { user.Username }, new string[] { roleName });
}
public void AddUsersToRole(string[] usernames, string roleName)
{
roleProvider.AddUsersToRoles(usernames, new string[] { roleName });
}
