protected override void Seed(MPSContext context)
{
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
var userManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
//uzytkownicy o roli Admin
roleManager.Create(new IdentityRole("Admin"));
var u1 = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******"
};
string passwor = "Biblioteka1@";
userManager.Create(u1, passwor);
userManager.AddToRole(u1.Id, "Admin");
var uu1 = new UserNew
{
UserName = "******",
Id = u1.Id
};
context.User.Add(uu1);
context.SaveChanges();
/* var P = new Person
* {
* Name = "",
* Surname = ""
*
* };*/
// context.Person.Add(P);
// context.SaveChanges();
}
public ActionResult New(UserNew form)
{
var user = new User();
SyncRoles(form.Roles, user.Roles);
if (Database.Session.Query <User>().Any(u => u.Username == form.UserName))
{
ModelState.AddModelError("Username", "Username must be unique");
}
if (!ModelState.IsValid)
{
return(View(form));
}
user.Email = form.Email;
user.Username = form.UserName;
user.SetPassword(form.Password);
Database.Session.Save(user);
return(RedirectToAction("index"));
}
public async Task TestChangeUserRole()
{
var userNew = new UserNew().SetDefaults();
userNew.Password = "******";
userNew.Role = Role.User;
userNew.Username = "******" + new Guid().ToString();
var createUserRequest = new CreateUserRequest(userNew);
var createUserResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createUserRequest);
var userId = createUserResponse.Content.Id;
var userRoleChange = new ChangeUserRoleBody().SetDefaults();
userRoleChange.Role = Role.Manager;
Assert.NotNull(userRoleChange.ToJson());
Assert.NotNull(userRoleChange.ToString());
await SkyManager.ApiClient.ExecuteRequestAsync(new ChangeUserRoleRequest(userRoleChange, userId));
var getUserResponse = await SkyManager.ApiClient.ExecuteRequestAsync(new GetUserRequest(userId));
Assert.Equal(Role.Manager, getUserResponse.Content.Role);
await SkyManager.ApiClient.ExecuteRequestAsync(new DeleteUserRequest(userId));
}
//Create
public static SessionUser Create(UserNew user)
{
return(new SessionUser
{
Address_Billing = user.AddressBilling,
Address_Shipping = user.AddressShipping,
CommRate_ID = user.Commission_ID,
Email = user.Email,
FirstName = user.AddressBilling.FirstName,
ID = user.ID,
IP = user.IP,
IsAddressBillingLikeShipping = user.IsBillingLikeShipping,
IsConsignorShip = user.IsConsignorShip,
LastName = user.AddressBilling.LastName,
Login = user.Login,
NotRecieveNewsUpdates = user.NotRecieveNewsUpdates,
NotRecieveWeeklySpecials = user.NotRecieveWeeklySpecials,
NotRecievingBidConfirmation = user.NotRecievingBidConfirmation,
NotRecievingLotClosedNotice = user.NotRecievingLotClosedNotice,
NotRecievingLotSoldNotice = user.NotRecievingLotSoldNotice,
NotRecievingOutBidNotice = user.NotRecievingOutBidNotice,
SellerLocation = String.Format("{0}, {1}", user.AddressBilling.City, user.AddressBilling.State),
Status = user.Status,
UserType = user.Type
});
}
public HttpResponseMessage GetUserFeedbacks()
{
var UserFeedbacks = from UserFeedback in db.UserFeedbacks
join User in db.Users on UserFeedback.UserId equals User.Id into UserNew
from User in UserNew.DefaultIfEmpty()
select new { UserFeedback.Id, UserFeedback.FeedBack, User.Name, UserFeedback.CreatedOn };
return((HttpResponseMessage)Request.CreateResponse(HttpStatusCode.OK, new { data = new { UserFeedbacks }, success = true, error = string.Empty }));
}
public UserNew CreateGrade(ApplicationUser user, New news, double rating)
{
UserNew userNew = new UserNew()
{
ApplicationUserId = user.Id,
NewId = news.Id,
Rating = rating,
};
return(userNew);
}
private void AddAndValidateRating(ApplicationUser author, New currentNew, UserNew rating)
{
try
{
DeleteDuplicate(author, currentNew);
SaveRating(rating);
}
catch (Exception)
{
SaveRating(rating);
}
}
//
// GET: /User/Create
public ActionResult Create()
{
if (!Access.HasAccess(2))
{
System.Web.Routing.RouteValueDictionary route = new System.Web.Routing.RouteValueDictionary();
route.Add("err", "Нет доступа!");
return(RedirectToAction("Error", "Home", route));
}
UserNew theUser = new UserNew();
return(View(theUser));
}
public async Task <IActionResult> SetStar(double currentRating, string user, Guid id)
{
ApplicationUser author = await _userManager.FindByIdAsync(user);
New currentNew = await _context.News.FirstOrDefaultAsync(z => z.Id == id);
UserNew rating = CreateGrade(author, currentNew, currentRating);
AddAndValidateRating(author, currentNew, rating);
await CalculateRating(currentNew);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Register([FromBody] UserNew userNew)
{
try
{
await _userService.RegisterAsync(userNew);
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
}
public IActionResult CreateUser([FromBody] UserNew u)
{
User tAdd = new User();
tAdd.email = u.email;
tAdd.login = u.login;
tAdd.password = _ph.GetHash(u.password);
tAdd.userId = 0;
tAdd.score = 1000;
var nUser = _userData.AddUser(tAdd);
if (nUser.userId != 0)
{
return(Ok(nUser));
}
return(Ok(new User()));
}
public void AgencyPasswordPolicy_CheckPasswordDate()
{
UserNew userdetails = new UserNew();
passwordConfiguration = new PasswordConfigurationNew();
passwordConfiguration.PasswordPolicy = true;
passwordConfiguration.MaximumLength = 15;
controllerInstance = new AgencyPasswordPolicy(passwordConfiguration);
try
{
controllerInstance.IsPasswordExpired(userdetails);
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsNotNull(exception);
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
var user1 = await UserManager.FindByNameAsync(model.Email);
var userId = user1.Id;
if (UserManager.FindByName("Uzytkownik") == null)
{
if (result.Succeeded)
{
var result1 = userManager.AddToRole(userId, "Uzytkownik");
}
}
var myUser = new UserNew()
{
UserName = model.Email,
Id = userId,
};
db.User.Add(myUser);
db.SaveChanges();
if (result.Succeeded)
{
return(RedirectToAction("Edit", "Uzytkownik", new { id = userId }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task TestUpdateUser()
{
var userNew = new UserNew().SetDefaults();
userNew.Password = "******";
userNew.Role = Role.User;
userNew.Username = "******" + new Guid().ToString();
var createUserRequest = new CreateUserRequest(userNew);
var createUserResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createUserRequest);
var userId = createUserResponse.Content.Id;
var userUpdate = new UserUpdate().SetDefaults();
userUpdate.Avatar = "";
userUpdate.City = "City";
userUpdate.Email = "*****@*****.**";
userUpdate.FirstName = "Test";
userUpdate.JobTitle = "Tester";
userUpdate.LastName = "User";
userUpdate.Locale = "eng";
userUpdate.Location = "Test Center";
userUpdate.MobilePhone = "(123) 456-7890";
userUpdate.OfficePhone = "(123) 456-7890";
userUpdate.State = "State";
userUpdate.Street = "Street";
userUpdate.Username = "******" + new Guid().ToString();
userUpdate.Zipcode = 12345;
Assert.NotNull(userUpdate.ToJson());
Assert.NotNull(userUpdate.ToString());
await SkyManager.ApiClient.ExecuteRequestAsync(new UpdateUserRequest(userUpdate, userId));
var getUserResponse = await SkyManager.ApiClient.ExecuteRequestAsync(new GetUserRequest(userId));
Assert.Equal("City", getUserResponse.Content.City);
await SkyManager.ApiClient.ExecuteRequestAsync(new DeleteUserRequest(userId));
}
public void AgencyPasswordPolicy_ValidatePasswordForInvalidReuseCount()
{
DeveloperIdentity.GetDeveloperIdentity();
const string password = "******";
Guid userId = Utils.CreateUser(password);
UserNew userdetails = new UserNew()
{
PasswordHistory = new Collection <PasswordHistory>()
{
new PasswordHistory(new Password(new Guid(), userId, "abc")),
new PasswordHistory(new Password(new Guid(), userId, "xyz"))
}
};
passwordConfiguration = new PasswordConfigurationNew();
passwordConfiguration.PasswordPolicy = true;
passwordConfiguration.PasswordReuse = 5;
passwordConfiguration.MaximumLength = 15;
controllerInstance = new AgencyPasswordPolicy(passwordConfiguration);
passwordViolations = controllerInstance.ValidatePasswordChange(userdetails, password);
Assert.IsFalse(passwordViolations.Count > 0);
}
public async Task TestChangePassword()
{
var userPassword = "******";
var userNew = new UserNew().SetDefaults();
userNew.Username = "******" + new Guid().ToString();
userNew.Password = userPassword;
userNew.Role = Role.User;
var createUserRequest = new CreateUserRequest(userNew);
var createUserResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createUserRequest);
var userId = createUserResponse.Content.Id;
var changeUserPasswordBody = new ChangeUserPasswordBody().SetDefaults();
changeUserPasswordBody.NewPassword = "******";
changeUserPasswordBody.Temporary = false;
Assert.NotNull(changeUserPasswordBody.ToJson());
Assert.NotNull(changeUserPasswordBody.ToString());
await SkyManager.ApiClient.ExecuteRequestAsync(new ChangeUserPasswordRequest(changeUserPasswordBody, userId));
await SkyManager.ApiClient.ExecuteRequestAsync(new DeleteUserRequest(userId));
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("filterContext");
}
if (AuthorizeCore(filterContext.HttpContext))
{
var principal = (filterContext.HttpContext.User as VauctionPrincipal);
if (principal == null)
{
LogOutUser(filterContext); return;
}
var user = AppHelper.CurrentUser;
if (user == null)
{
LogOutUser(filterContext); return;
}
//#region added 2013-03-15 -> cross session check
//VauctionIdentity videntity = principal.UIdentity;
//if (videntity.ID != user.ID)
//{
// Logger.LogInfo(String.Format("[SESSION-ERROR][NOTCHECK]: SessionID:{0} | CurrentUser:{1} | CrossedUser: {2} | IP: {3} | Local IP: {4}\n\t\t\tUser Agent: {5}", HttpContext.Current.Session.SessionID, videntity.ID, user.ID, Consts.UsersIPAddress, HttpContext.Current.Request.ServerVariables["LOCAL_ADDR"], HttpContext.Current.Request.UserAgent));
// LogOutUser(filterContext); return;
//}
//#endregion
bool isNeedToCheckStatus = principal.IsNeedToCheckStatus(statusCheckTime);
if (isNeedToCheckStatus)
{
VauctionIdentity identity = principal.UIdentity;
UserNew usr = ProjectConfig.Config.DataProvider.GetInstance().UserRepository.GetUserActiveAndApproved(identity.ID, identity.Name);
if (usr != null && usr.Status == (byte)Consts.UserStatus.Active)
{
//IFormsAuthenticationService formsService = new FormsAuthenticationService();
//formsService.SignIn(usr.Login, identity.RememberMe, usr.ID);
}
else
{
LogOutUser(filterContext);
return;
}
}
bool isbackend = false;
if (!String.IsNullOrEmpty(IsBackendUser) && Boolean.TryParse(IsBackendUser, out isbackend) && isbackend && !user.IsAdminType)
{
LogOutUser(filterContext);
return;
}
if (!String.IsNullOrEmpty(Roles))
{
string[] roles = Roles.Split(',');
bool res = false;
foreach (string role in roles)
{
if (res = (role.Equals(((Consts.UserTypes)user.UserType).ToString(), StringComparison.InvariantCulture)))
{
break;
}
}
if (!res)
{
NotAuthorized(filterContext);
}
}
}
else if (!filterContext.HttpContext.User.Identity.IsAuthenticated)
{
NotAuthorized(filterContext);
}
}
public static void SetMainControl(ERMTControl view)
{
ERMTUserControl currentUserControl = new ERMTUserControl {
Name = "new"
};
switch (view)
{
case ERMTControl.About:
{
About about = new About();
about.ShowDialog();
break;
}
case ERMTControl.EditRegion:
{
EditRegion editRegion = new EditRegion();
currentUserControl = editRegion;
SetMainControl(editRegion);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.ElectoralCycle:
{
IndexUserControl indexUserControl = new IndexUserControl
{
IndexContentType = IndexContentType.ElectoralCycle
};
currentUserControl = indexUserControl;
SetMainControl(indexUserControl);
ApplicationPrincipalForm.LoadLeftButtons("electoralcycle");
indexUserControl.ShowHtml();
break;
}
case ERMTControl.ElectoralCycleModifyPhase:
{
ElectoralCycleModifyPhase electoralCycleModifyPhase = new ElectoralCycleModifyPhase();
currentUserControl = electoralCycleModifyPhase;
SetMainControl(electoralCycleModifyPhase);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.FactorModify:
{
FactorModify modifyFactor = new FactorModify();
currentUserControl = modifyFactor;
SetMainControl(modifyFactor);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.FactorNew:
{
FactorNew newFactor = new FactorNew();
currentUserControl = newFactor;
SetMainControl(newFactor);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.FactorReorder:
{
FactorsReorder reorderFactors = new FactorsReorder();
currentUserControl = reorderFactors;
SetMainControl(reorderFactors);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.KnowledgeResources:
{
IndexUserControl indexUserControl = new IndexUserControl
{
IndexContentType = IndexContentType.KnowledgeResources
};
currentUserControl = indexUserControl;
SetMainControl(indexUserControl);
ApplicationPrincipalForm.LoadLeftButtons("KnowledgeResources");
indexUserControl.ShowHtml();
break;
}
case ERMTControl.Login:
{
LoginUserControl loginUserControl = new LoginUserControl();
currentUserControl = loginUserControl;
SetMainControl(loginUserControl);
break;
}
case ERMTControl.MarkerTypeCRUD:
{
MarkerTypeCRUD markerTypeControl = new MarkerTypeCRUD();
currentUserControl = markerTypeControl;
SetMainControl(markerTypeControl);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.ModelEdit:
{
ModelEdit modelEdit = new ModelEdit();
currentUserControl = modelEdit;
SetMainControl(modelEdit);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.ModelNew:
{
ModelNew modelNew = new ModelNew();
currentUserControl = modelNew;
SetMainControl(modelNew);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.ModelReorderFactors:
{
ModelReorderFactors modelReorderFactors = new ModelReorderFactors();
currentUserControl = modelReorderFactors;
SetMainControl(modelReorderFactors);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.RiskActionRegister:
{
RiskAndActionRegister riskActionRegister = new RiskAndActionRegister(true);
currentUserControl = riskActionRegister;
SetMainControl(riskActionRegister);
ApplicationPrincipalForm.LoadLeftButtons("riskandaction");
break;
}
case ERMTControl.RiskMapping:
{
//RiskMapping riskMapping = new RiskMapping();
//currentUserControl = riskMapping;
//SetMainControl(riskMapping);
currentUserControl = ControlCache.RiskMappingInstance;
SetMainControl(ControlCache.RiskMappingInstance);
ApplicationPrincipalForm.LoadLeftButtons("map");
break;
}
case ERMTControl.Start:
{
SetMainControl(ControlCache.StartInstance);
currentUserControl = ControlCache.StartInstance;
ApplicationPrincipalForm.LoadLeftButtons("Start");
break;
}
case ERMTControl.TestUserControl:
{
TestUserControl testUserControl = new TestUserControl();
SetMainControl(testUserControl);
break;
}
case ERMTControl.UserModify:
{
UserModify userModify = new UserModify();
currentUserControl = userModify;
SetMainControl(userModify);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.UserNew:
{
UserNew userNew = new UserNew();
currentUserControl = userNew;
SetMainControl(userNew);
ApplicationPrincipalForm.LoadLeftButtons();
break;
}
case ERMTControl.UserResetPassword:
{
UserChangePassword ucp = new UserChangePassword();
ucp.ShowDialog();
break;
}
}
if (currentUserControl.Name != "new")
{
currentUserControl.ShowTitle();
}
}
public async Task <IActionResult> NewUser(UserNew form, string returnUrl, string action)
{
if (action == "Create")
{
if (ModelState.IsValid)
{
if (await _userManager.FindByEmailAsync(form.Email) == null)
{
var user = new AuthUser();
user.UserName = form.Email;
user.Email = form.Email;
user.EmailConfirmed = form.EmailConfirmed;
user.NormalizedEmail = form.Email.ToUpper();
await _userManager.CreateAsync(user, form.Password);
foreach (var role in form.CheckBoxRoles)
{
if (role.IsChecked)
{
await _userManager.AddToRoleAsync(user, role.Name);
}
else
{
await _userManager.RemoveFromRoleAsync(user, role.Name);
}
}
if (string.IsNullOrWhiteSpace(returnUrl))
{
return(RedirectToAction("Index", "User"));
}
else
{
return(Redirect(returnUrl));
}
}
else
{
ModelState.AddModelError("", "User creation failed: User's email must be unique!");
return(View());
}
}
}
else
{
return(RedirectToAction("index", "user"));
}
//in case it failed to create new user and need to show Errors on the screen
List <AuthRole> authRoles = _roleManager.Roles.ToList();
return(View(new UserNew
{
CheckBoxRoles = authRoles.Select(role => new RoleCheckBox
{
Id = role.Id,
IsChecked = false,
Name = role.Name
}).ToList()
}));
}
private void SaveRating(UserNew rating)
{
_context.UserNews.Add(rating);
_context.SaveChanges();
}
public ActionResult <bool> Add(UserNew user)
{
LogContent = "新建用户，用户名：" + user.Login;
return(bll.Add(user));
}
public async Task RegisterAsync(UserNew userNew)
{
await _userService.RegisterAsync(userNew);
}
