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 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 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);
}
