public async Task EnsureSeedData() { if (await _userManager.FindByEmailAsync("*****@*****.**") == null) { // Add the user var newUser = new BlogUser() { UserName = "******", Email = "*****@*****.**" }; await _userManager.CreateAsync(newUser, "123321"); } if (!_contex.Categories.Any()) { var category = new Category() {Name = "Main", Description = "Descr"}; _contex.Categories.Add(category); var firstPost = new Post() { Category = category, Title = "First Post" }; _contex.Posts.Add(firstPost); _contex.SaveChanges(); } }
public BlogsByUserViewModel(string username) { // Get back to the original name before url conversion BlogUsername = username.Replace(ContentGlobals.BLOGDELIMMETER, " "); using (var context = new DataContext()) { // Get User based on authorid TheBlogUser = context.BlogUsers.FirstOrDefault(x => x.Username == BlogUsername); MaxBlogCount = BlogListModel.GetBlogSettings().MaxBlogsOnHomepageBeforeLoad; BlogTitle = BlogListModel.GetBlogSettings().BlogTitle; BlogsByUser = context.Blogs.Where(x => x.Author == BlogUsername && x.IsActive) .OrderByDescending(blog => blog.Date) .Take(MaxBlogCount) .ToList(); // Try permalink first TheBlog = BlogsByUser.FirstOrDefault(x => x.Author == BlogUsername); if (BlogsByUser.Count > 0) { LastBlogId = BlogsByUser.LastOrDefault().BlogId; } } }
protected static void SetUserToContext(HttpContext context, BlogUser user) { var serializer = new JavaScriptSerializer(); var userData = serializer.Serialize(user); var ticket = new FormsAuthenticationTicket(1, user.Identity.Name, DateTime.UtcNow, DateTime.UtcNow.AddDays(2), true, userData); var encryptedTicket = FormsAuthentication.Encrypt(ticket); var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket); context.Response.Cookies.Add(cookie); }
public void EditUser(EditUserViewModel userModel) { var newRole = new IdentityUserRole(); BlogUser user = UserManager.FindByEmail(userModel.Email); user.Roles.Clear(); newRole.RoleId = RoleManager.FindByName(userModel.Role).Id; newRole.UserId = user.Id; if (user != null || !string.IsNullOrEmpty(userModel.Email)) { user.Email = userModel.Email; user.Roles.Add(newRole); UserManager.Update(user); } }
public ActionResult Login([Bind(Include = "Username,Password")] BlogUser fan) { if (ModelState.IsValid) { BlogUser loggedUser = db.BlogUsers.Where(user => user.UserName.Equals(fan.UserName) && user.Password.Equals(fan.Password)).FirstOrDefault(); if (loggedUser != null) { LoginManager.Instance.CurrentLogedUser = loggedUser; return(RedirectToAction("Index", "Blog")); } ViewBag.ErrorMessage = "Invalid Username or Password! Please try again.."; return(View()); } return(RedirectToAction("Error")); }
public void AddUser(string userName, string email, string phone, string password, string role) { var userMgr = new UserManager <BlogUser>(new UserStore <BlogUser>(context)); var user = new BlogUser() { UserName = userName, Email = email, PhoneNumber = phone }; userMgr.Create(user, password); userMgr.AddToRole(user.Id, role); context.SaveChanges(); }
public static async Task SeedModerator(UserManager <BlogUser> userManager) { if (await userManager.FindByEmailAsync("*****@*****.**") == null) { var moderator = new BlogUser() { Email = "*****@*****.**", UserName = "******", FirstName = "Jason", LastName = "Twitchell", EmailConfirmed = true }; await userManager.CreateAsync(moderator, "Jtwitchell1!"); await userManager.AddToRoleAsync(moderator, Roles.Moderator.ToString()); } }
// GET: Blog public ActionResult IndexBlogsOfUser() { BlogUser currentUser = (BlogUser)Session["user"]; if (currentUser == null) { return(View("~/Views/Account/NotLogged.cshtml")); } var contextProvider = new MysqlContextProvider(); using (var context = contextProvider.CreateContext <BlogContext>()) // explicitly authenticated by user2 { var blogs = context.BlogPosts.Where(x => x.CreatedBy.Id.Equals(currentUser.Id)).ToList(); return(View(blogs)); } return(View("~/Views/Shared/Error.cshtml")); }
private void SetUserRoles(EditUserViewModel viewModel, BlogUser user, BlogDbContext database) { var userManager = HttpContext.GetOwinContext() .GetUserManager <ApplicationUserManager>(); foreach (var role in viewModel.Roles) { if (role.IsSelected && !userManager.IsInRole(user.Id, role.Name)) { userManager.AddToRole(user.Id, role.Name); } else if (!role.IsSelected && userManager.IsInRole(user.Id, role.Name)) { userManager.RemoveFromRole(user.Id, role.Name); } } }
public JsonResult LikeCount(int id, int value) { LikeManager likeManager = new LikeManager(); BlogUser user = Session["login"] as BlogUser; if (user != null) { int likevalue = likeManager.GetLike(id); return(Json(new { result = likevalue }, JsonRequestBehavior.AllowGet)); } else { return(Json(new { result = false }, JsonRequestBehavior.AllowGet)); } }
public static async Task SeedModerator(UserManager <BlogUser> userManager) { if (await userManager.FindByEmailAsync("*****@*****.**") == null) //adds a fake BlogUser - Moderator { var moderator = new BlogUser() { UserName = "******", Email = "*****@*****.**", FirstName = "Adam", LastName = "West", EmailConfirmed = true }; await userManager.CreateAsync(moderator, "!1Qwerty"); await userManager.AddToRoleAsync(moderator, Roles.Moderator.ToString()); } }
public static async Task SeedAdministrator(UserManager <BlogUser> userManager) { if (await userManager.FindByEmailAsync("*****@*****.**") == null) //adds me as BlogUser - Admin { var admin = new BlogUser() { UserName = "******", Email = "*****@*****.**", FirstName = "Josh", LastName = "Scott", EmailConfirmed = true }; await userManager.CreateAsync(admin, "!1Qwerty"); await userManager.AddToRoleAsync(admin, Roles.Administrator.ToString()); } }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new BlogUser { UserName = Input.Email, Email = Input.Email, Name = Input.Name, DisplayName = Input.DisplayName }; var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); //Add a user to the default role "Follower" await _userManager.AddToRoleAsync(user, "Follower"); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Page( "/Account/ConfirmEmail", pageHandler: null, values: new { userId = user.Id, code = code }, protocol: Request.Scheme); await _emailSender.SendEmailAsync(Input.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); await _signInManager.SignInAsync(user, isPersistent : false); return(RedirectToAction("Index", "Blog")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(Page()); }
public static async Task SeedAdmin(UserManager <BlogUser> userManager) { if (await userManager.FindByEmailAsync("*****@*****.**") == null) { var admin = new BlogUser() { Email = "*****@*****.**", UserName = "******", FirstName = "Mackenzie", LastName = "Weaver", EmailConfirmed = true }; await userManager.CreateAsync(admin, "Mweaver1!"); await userManager.AddToRoleAsync(admin, Roles.Admin.ToString()); } }
public ActionResult Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } var userManager = HttpContext.GetOwinContext().GetUserManager <UserManager <BlogUser> >(); var authManager = HttpContext.GetOwinContext().Authentication; // attempt to load the user with this password BlogUser user = userManager.Find(model.UserName, model.Password); // user will be null if the password or user name is bad if (user == null) { ModelState.AddModelError("", "Invalid username or password"); return(View(model)); } else { // successful login, set up their cookies and send them on their way var identity = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie); authManager.SignIn(new AuthenticationProperties { IsPersistent = model.RememberMe }, identity); if (!string.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { if (userManager.IsInRole(user.Id, "Disabled")) { return(RedirectToAction("AccountDisabled")); } else { return(RedirectToAction("Index", "Home")); } } } }
public async Task CreateUserAsync(BlogUser user) { var uniqueUsername = new UniqueUsername { Username = user.Username }; //First create a user with a partitionkey as "unique_username" and the new username. Using the same partitionKey "unique_username" will put all of the username in the same logical partition. // Since there is a Unique Key on /username (per logical partition), trying to insert a duplicate username with partition key "unique_username" will cause a Conflict. // This question/answer https://stackoverflow.com/a/62438454/21579 await _usersContainer.CreateItemAsync <UniqueUsername>(uniqueUsername, new PartitionKey(uniqueUsername.UserId)); user.Action = "Create"; //if we get past adding a new username for partition key "unique_username", then go ahead and insert the new user. await _usersContainer.CreateItemAsync <BlogUser>(user, new PartitionKey(user.UserId)); //await _usersContainer.CreateItemAsync<BlogUser>(user, new PartitionKey(user.UserId), new ItemRequestOptions { PreTriggers = new List<string> { "validateUserUsernameNotExists" } }); }
private async Task LoadSharedKeyAndQrCodeUriAsync(BlogUser user) { // Load the authenticator key & QR code URI to display on the form var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user); if (string.IsNullOrEmpty(unformattedKey)) { await _userManager.ResetAuthenticatorKeyAsync(user); unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user); } SharedKey = FormatKey(unformattedKey); var email = await _userManager.GetEmailAsync(user); AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey); }
public ActionResult ShowProfile(BlogUser user) { BusinessLayerResult <BlogUser> res = blogUserManager.GetUserById(CurrentSession.User.Id); if (res.Errors.Count > 0) { ErrorViewModel errorNotifyObj = new ErrorViewModel() { Title = "Hata Oluştu", Items = res.Errors }; return(View("Error", errorNotifyObj)); } return(View(res.Result)); }
private async Task SeedUsersAsync() { if (_context.Users.Any()) { return; } var adminUser = new BlogUser() { Email = "*****@*****.**", UserName = "******", GivenName = "Kasey", SurName = "Wahl", PhoneNumber = "555-5555", EmailConfirmed = true, ImageData = await _fileService.EncodeFileAsync("kasey_cropped.png"), ContentType = "png" }; var modUser = new BlogUser() { Email = "*****@*****.**", UserName = "******", GivenName = "Yogi", SurName = "Bear", PhoneNumber = "444-4444", EmailConfirmed = true, ImageData = await _fileService.EncodeFileAsync("yogi.jpg"), ContentType = "jpg" }; //await _userManager.CreateAsync(adminUser, "Abc123!"); //Only creates the user, doesn't assign user to a role await _userManager.CreateAsync(adminUser, _configuration["AdminPassword"]); //await _userManager.AddToRoleAsync(adminUser, "Administrator"); await _userManager.AddToRoleAsync(adminUser, BlogRole.Administrator.ToString()); //Create the mod user (but not the role yet) await _userManager.CreateAsync(modUser, _configuration["ModPassword"]); //Assign mod to the role await _userManager.AddToRoleAsync(modUser, BlogRole.Moderator.ToString()); }
public async Task <ActionResult <Blog> > NewBlog([FromBody] AddNewBlog model) { var CheckBlogName = _context.Blogs.FirstOrDefault(x => x.Title == model.Title); if (CheckBlogName != null) { return(BadRequest("Title has exist")); } Blog blog = new Blog() { Title = model.Title, IntroImage = model.IntroImage, Description = model.Description, Like = 0, Status = false, Paragraphs = model.paragraphs, Time = DateTime.UtcNow }; foreach (UserModel user in model.ListAuthor) { var CheckAuthor = _context.Users.FirstOrDefault(x => x.Id == user.Id); if (CheckAuthor != null) { BlogUser blogUser = new BlogUser() { User = CheckAuthor, Blog = blog }; _context.BlogUsers.Add(blogUser); } else { return(BadRequest("Author not found")); } } ; _context.Blogs.Add(blog); await _context.SaveChangesAsync(); return(CreatedAtAction("GetBlog", new { id = blog.BlogId }, blog)); }
public BlogSingleHomeViewModel(string title) { using (var context = new DataContext()) { // Try permalink first TheBlog = context.Blogs.FirstOrDefault(x => x.PermaLink == title); // If no go then try title as a final back up if (TheBlog == null) { title = title.Replace(Utils.ContentGlobals.BLOGDELIMMETER, " "); TheBlog = context.Blogs.FirstOrDefault(x => x.Title == title); // Go ahead and set the permalink for future reference TheBlog.PermaLink = Utils.ContentUtils.GetFormattedUrl(TheBlog.Title); context.SaveChanges(); } // Set up the Related Posts Module RelatedPosts = new BlogRelatedViewModel(TheBlog.Title); // Get User based on authorid TheBlogUser = context.BlogUsers.FirstOrDefault(x => x.UserId == TheBlog.AuthorId); string username = TheBlogUser != null ? TheBlogUser.DisplayName : "Anonymous"; BlogAuthorModel = new BlogAuthorViewModel(username); // Facebook Like button ShowFacebookLikeButton = SiteSettingsUtils.ShowFbLikeButton(); // Facebook Comments ShowFacebookComments = SiteSettingsUtils.ShowFbComments(); // Absolute Url for FB Like Button BlogAbsoluteUrl = HttpContext.Current.Request.Url.AbsoluteUri; // Disqus Comments UseDisqusComments = SiteSettingsUtils.UseDisqusComments(); if (UseDisqusComments) { DisqusShortName = SiteSettingsUtils.DisqusShortName(); } } }
public async Task <IActionResult> RegisterAsync(RegisterAPIModel model) { if (model.Password == model.Confirmpassword) { var newuser = new BlogUser() { Email = model.Email, UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName }; var result = await _userManager.CreateAsync(newuser, model.Password); if (result.Succeeded) { var userFromDb = await _userManager.FindByEmailAsync(newuser.UserName); var token = await _userManager.GenerateEmailConfirmationTokenAsync(userFromDb); var uriBuilder = new UriBuilder(_config["ReturnPaths:confirmemail"]); var query = HttpUtility.ParseQueryString(uriBuilder.Query); query["token"] = token; query["userid"] = userFromDb.Id; uriBuilder.Query = query.ToString(); var urlString = uriBuilder.ToString(); await _emailSender.SendEmailAsync(userFromDb.Email, "Confirm your email address", $"Please confirm your account by <a href='{urlString}'>clicking here</a>."); //Add role to user //await _userManager.AddToRoleAsync(userFromDb, model.Role); //var claim = new Claim("JobTitle", model.JobTitle); //await _userManager.AddClaimAsync(userFromDb, claim); return(Ok(result)); } return(BadRequest(result)); } return(BadRequest()); }
private static async Task SeedAdmin(UserManager <BlogUser> userManager) { if (await userManager.FindByEmailAsync("*****@*****.**") == null) { var admin = new BlogUser() { Email = "*****@*****.**", UserName = "******", FirstName = "Jackson", LastName = "Holliday", DisplayName = "Jackson Holliday", EmailConfirmed = true }; await userManager.CreateAsync(admin, "Abc&123!"); await userManager.AddToRoleAsync(admin, Roles.Admin.ToString()); } }
private static async Task SeedModerator(UserManager <BlogUser> userManager) { if (await userManager.FindByEmailAsync("*****@*****.**") == null) { var moderator = new BlogUser() { Email = "*****@*****.**", UserName = "******", FirstName = "Andrew", LastName = "Holliday", DisplayName = "DrewMod", EmailConfirmed = true }; await userManager.CreateAsync(moderator, "Abc&123!"); await userManager.AddToRoleAsync(moderator, Roles.Admin.ToString()); } }
private async Task LoadAsync(BlogUser user) { var userName = await _userManager.GetUserNameAsync(user); var phoneNumber = await _userManager.GetPhoneNumberAsync(user); Username = userName; CurrentImage = _fileService.DecodeImage(user.ImageData, user.ContentType); Input = new InputModel { DisplayName = user.DisplayName, PhoneNumber = phoneNumber, GivenName = user.GivenName, SurName = user.SurName, //ProfilePic = user.ImageData, //ContentType = user.ContentType, }; }
public BlogAuthorViewModel(string username) { // Get back to the original name before url conversion BlogUsername = username.Replace(ContentGlobals.BLOGDELIMMETER, " "); TheBlog = Context.Blogs.FirstOrDefault(x => x.BlogAuthor.Username == BlogUsername); // Get User based on authorid TheBlogUser = Context.BlogUsers.FirstOrDefault(x => x.Username == BlogUsername); // Facebook Like button ShowFacebookLikeButton = SettingsUtils.ShowFbLikeButton(); // Facebook Comments ShowFacebookComments = SettingsUtils.ShowFbComments(); // Absolute Url for FB Like Button BlogAbsoluteUrl = HttpContext.Current.Request.Url.AbsoluteUri; }
public JsonResult GetLiked(int [] ids) { LikeManager likeManager = new LikeManager(); BlogUser user = Session["login"] as BlogUser; //burada eğer kullanıcı login olmadıysa buna göre bir düzenleme yapılmalı //!!!!!!!!!!!!!!!!!!! if (user != null) { List <int> likedNoteIds = likeManager.GetLikes(user.Id, ids); return(Json(new { result = likedNoteIds }, JsonRequestBehavior.AllowGet)); } else { return(Json(new { result = false }, JsonRequestBehavior.AllowGet)); } }
public async Task <bool> CreateAsync(RegisterViewModel model) { var user = new BlogUser { Email = model.Email, UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, true); } return(result.Succeeded); }
public bool Regist(ViewModels.RegisterUser addOne) { var isRegist = false; var res = repository.GetUserByAccount(addOne.Account); if (res == null) { BlogUser NewBlog = new BlogUser { Account = addOne.Account, Password = md5tool.GetMD5(addOne.Password), Name = addOne.Name }; repository.AddUser(NewBlog); isRegist = true; return(isRegist); } return(isRegist); }//注册
public ActionResult Edit(BlogUser blogUser) { ModelState.Remove("CreatedOn"); ModelState.Remove("ModifiedOn"); ModelState.Remove("ModifierUsername"); if (ModelState.IsValid) { BusinessLayerResult <BlogUser> res = BlogUserManager.Update(blogUser); if (res.Errors.Count > 0) { res.Errors.ForEach(x => ModelState.AddModelError("", x.Message)); return(View(blogUser)); } return(RedirectToAction("Index")); } return(View(blogUser)); }
public async Task <ResultData <ResponseModel> > Login(string email, string password) { if (string.IsNullOrEmpty(email)) { return(new ResultData <ResponseModel>(Constants.InvalidEmailOrPasswordMessage, false, null)); } Match match = Regex.Match(email, Constants.EmailPattern); if (!match.Success) { return(new ResultData <ResponseModel>(Constants.InvalidEmailOrPasswordMessage, false, null)); } if (string.IsNullOrEmpty(password)) { return(new ResultData <ResponseModel>(Constants.InvalidEmailOrPasswordMessage, false, null)); } if (password.Length < 3) { return(new ResultData <ResponseModel>(Constants.InvalidEmailOrPasswordMessage, false, null)); } BlogUser user = await this.signInManager.UserManager.Users.FirstOrDefaultAsync(u => u.Email == email); if (user == null) { return(new ResultData <ResponseModel>(Constants.InvalidEmailOrPasswordMessage, false, null)); } bool passwordIsCorrect = await this.signInManager.UserManager.CheckPasswordAsync(user, password); if (!passwordIsCorrect) { return(new ResultData <ResponseModel>(Constants.InvalidEmailOrPasswordMessage, false, null)); } ResponseModel model = this.CreateResponseModel(user); return(new ResultData <ResponseModel>(Constants.UserLoginSuccessMessage, true, model)); }
public bool DeleteComment(BlogUser user, int blogCommentId) { var blogEntry = _context.BlogEntries.Include(blog => blog.Comments).FirstOrDefault(p => p.Comments.Any(c => c.BlogCommentId == blogCommentId)); if (blogEntry == null) { throw new ArgumentException("Blog entry not found for comment id", nameof(blogCommentId)); } var blogComment = blogEntry.Comments.FirstOrDefault(p => p.BlogCommentId == blogCommentId); if (blogComment == null) { return(false); } blogEntry.Comments.Remove(blogComment); blogEntry.CommentCount = blogEntry.Comments.Count; _context.SaveChanges(); return(true); }
public string BuildToken(BlogUser user) { var claims = new[] { new Claim(JwtRegisteredClaimNames.Sub, user.FirstName), new Claim(JwtRegisteredClaimNames.Email, user.Email), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) }; var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:Key"])); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken( issuer: configuration["Jwt:Issuer"], audience: configuration["Jwt:Issuer"], claims: claims, expires: DateTime.Now.AddMinutes(30), signingCredentials: creds); return(new JwtSecurityTokenHandler().WriteToken(token)); }
private Boolean AuthenticateUser(BlogUser authenticationUser, string password) { if (authenticationUser == null) { return(false); } if (_securityManager.VerifyPassword(password, Convert.FromBase64String(authenticationUser.Password), Convert.FromBase64String(authenticationUser.PasswordSalt))) { _securityManager.SignIn(HttpContext, authenticationUser); } else { return(false); } _securityManager.SignIn(HttpContext, authenticationUser); return(true); }
public JsonResult AddBlogUser(BlogUser user) { var result = new JsonResult(); if (!String.IsNullOrEmpty(user.DisplayName)) { using (var context = new DataContext()) { var newUser = new BlogUser { CreateDate = DateTime.Now, DisplayName = user.DisplayName, Username = user.Username, IsActive = user.IsActive, UserImageLocation = user.UserImageLocation }; context.BlogUsers.Add(newUser); context.SaveChanges(); } } return result; }
public void Add(BlogUser entity) { base.Add(entity); }
public bool Contains(BlogUser entity) { return base.Contains(entity); }
public int IndexOf(BlogUser entity) { return base.IndexOf(entity); }
private bool UserPasswordIsValid(BlogUser blogUser, string password) { return !string.IsNullOrEmpty(password) && password == blogUser.Password; }
public JsonResult ModifyBlogUser(BlogUser user) { var success = 0; if (!String.IsNullOrEmpty(user.UserId.ToString())) { var editUser = Context.BlogUsers.FirstOrDefault(x => x.UserId == user.UserId); if (editUser == null) { return JsonErrorResult; } editUser.DisplayName = user.DisplayName; editUser.UserImageLocation = user.UserImageLocation; editUser.IsActive = user.IsActive; success = Context.SaveChanges(); } if (success > 0) { return new JsonResult { Data = new { success = true, message = "Changes saved successfully." } } ; } return JsonErrorResult; }
public JsonResult AddBlogUser(BlogUser user) { var success = 0; if (!String.IsNullOrEmpty(user.DisplayName)) { var newUser = new BlogUser { CreateDate = DateTime.UtcNow, DisplayName = user.DisplayName, Username = user.Username, IsActive = user.IsActive, UserImageLocation = user.UserImageLocation }; Context.BlogUsers.Add(newUser); success = Context.SaveChanges(); } if (success > 0) { return new JsonResult { Data = new { success = true, message = "User added successfully." } }; } return JsonErrorResult; }
public void ORM_LinqQuery_InnerJoin_TwoToSingleTable() { var repo = RF.Concrete<ArticleRepository>(); using (RF.TransactionScope(repo)) { var huqf = new BlogUser { UserName = "******" }; var admin = new BlogUser { UserName = "******" }; var admin2 = new BlogUser { UserName = "******" }; RF.Save(huqf); RF.Save(admin); RF.Save(admin2); repo.Save(new Article { User = huqf }); repo.Save(new Article { User = huqf, Administrator = admin }); repo.Save(new Article { User = huqf, Administrator = admin2 }); repo.Save(new Article { User = admin }); repo.Save(new Article { User = admin, Administrator = admin }); repo.Save(new Article { User = admin, Administrator = admin2 }); var list = repo.GetForTwoJoinTest(); Assert.IsTrue(list.Count == 2); Assert.IsTrue(list[0].AdministratorId == null); Assert.IsTrue(list[1].AdministratorId == admin.Id); } }
private ActionResult FinishAuthentication(UserModel user) { var blogUser = new BlogUser { Email = user.Email, Roles = user.Permissions.Select(a => a.ToString()).ToList(), UserId = user.UserId, Upn = user.Upn }; SetUserToContext(HttpContext.ApplicationInstance.Context, blogUser); return RedirectToRoute(RouteNames.Main); }
private async Task SignInAsync(BlogUser user, bool isPersistent) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie); ClaimsIdentity identity = await _userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = isPersistent }, identity); }
public async Task<ActionResult> CreateManagementUserPost(ManagementUserRequestModel requestModel) { // NOTE: Not a 100% safe way but will work out fine for the purpose of this action. bool anyUserExists = await DocumentSession.Query<BlogUser>().AnyAsync(); if (anyUserExists) { return HttpNotFound(); } if (ModelState.IsValid) { // refer to: https://groups.google.com/forum/#!searchin/ravendb/tugberk/ravendb/_7r5TcfJwx4/h5j7p4XQgeQJ DocumentSession.Advanced.UseOptimisticConcurrency = true; BlogUser blogUser = new BlogUser { Id = string.Concat("BlogUsers/", requestModel.Username), UserName = requestModel.Username, SecurityStamp = Guid.NewGuid().ToString() }; blogUser.Claims.Add(new RavenUserClaim { ClaimType = ClaimTypes.Email, ClaimValue = requestModel.Email }); blogUser.Claims.Add(new RavenUserClaim { ClaimType = _userManager.ClaimsIdentityFactory.RoleClaimType, ClaimValue = ApplicationRoles.AdminRole }); IdentityResult result = await _userManager.CreateAsync(blogUser, requestModel.Password); if (result.Succeeded) { await SignInAsync(blogUser, isPersistent: false); return RedirectToAction("Index", "Default"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form. return View(requestModel); }
public JsonResult DeleteBlogUser(BlogUser user) { var result = new JsonResult(); if (!String.IsNullOrEmpty(user.UserId.ToString())) { using (var context = new DataContext()) { var UserToDelete = context.BlogUsers.FirstOrDefault(x => x.UserId == user.UserId); context.BlogUsers.Remove(UserToDelete); context.SaveChanges(); } } return result; }
public bool Remove(BlogUser entity) { return base.Remove(entity); }
public Comment(string userComment, BlogUser blogUser) { UserComment = userComment; BlogUser = blogUser; }
public JsonResult ModifyBlogUser(BlogUser user) { var result = new JsonResult(); if (!String.IsNullOrEmpty(user.UserId.ToString())) { using (var context = new DataContext()) { var editUser = context.BlogUsers.FirstOrDefault(x => x.UserId == user.UserId); editUser.DisplayName = user.DisplayName; editUser.UserImageLocation = user.UserImageLocation; editUser.IsActive = user.IsActive; context.SaveChanges(); } } return result; }
public void Insert(int index, BlogUser entity) { base.Insert(index, entity); }