private void MarkPostUpOrDown(Post post, MembershipUser postWriter, MembershipUser voter, PostType postType) { // Check this user is not the post owner if (voter.Id != postWriter.Id) { // Not the same person, now check they haven't voted on this post before if (post.Votes.All(x => x.User.Id != LoggedOnUser.Id)) { // Points to add or subtract to a user var usersPoints = (postType == PostType.Negative) ? (-SettingsService.GetSettings().PointsDeductedNagativeVote) : (SettingsService.GetSettings().PointsAddedPostiveVote); // Update the users points who wrote the post _membershipUserPointsService.Add(new MembershipUserPoints { Points = usersPoints, User = postWriter }); // Update the post with the new vote of the voter var vote = new Vote { Post = post, User = voter, Amount = (postType == PostType.Negative) ? (-1) : (1), VotedByMembershipUser = LoggedOnUser, DateVoted = DateTime.Now }; _voteService.Add(vote); // Update the post with the new points amount var newPointTotal = (postType == PostType.Negative) ? (post.VoteCount - 1) : (post.VoteCount + 1); post.VoteCount = newPointTotal; } } }
public bool Rule(MembershipUser user) { // Get all down votes var voteService = DependencyResolver.Current.GetService<IVoteService>(); var downVotes = voteService.GetAllVotesByUser(user.Id).Where(x => x.Amount < 1).ToList(); return downVotes.Count() >= 10; }
public static MemberEditViewModel UserToMemberEditViewModel(MembershipUser user) { var viewModel = new MemberEditViewModel { IsApproved = user.IsApproved, Id = user.Id, IsLockedOut = user.IsLockedOut, IsBanned = user.IsBanned, Roles = user.Roles.Select(x => x.RoleName).ToArray(), UserName = user.UserName, Age = user.Age, Comment = user.Comment, Email = user.Email, Facebook = user.Facebook, Location = user.Location, PasswordAnswer = user.PasswordAnswer, PasswordQuestion = user.PasswordQuestion, Signature = user.Signature, Twitter = user.Twitter, Website = user.Website, DisableEmailNotifications = (user.DisableEmailNotifications == true), DisablePosting = (user.DisablePosting == true), DisablePrivateMessages = (user.DisablePrivateMessages == true), DisableFileUploads = (user.DisableFileUploads == true), Avatar = user.Avatar }; return viewModel; }
private void UpdateUserRoles(MVCForum.Domain.DomainModel.MembershipUser user, IEnumerable <string> updatedRoles) { var updatedRolesSet = new List <MembershipRole>(); foreach (var roleStr in updatedRoles) { var alreadyIsRoleForUser = false; foreach (var role in user.Roles) { if (roleStr == role.RoleName) { // This role for this user is UNchanged updatedRolesSet.Add(role); alreadyIsRoleForUser = true; break; } } if (!alreadyIsRoleForUser) { // This is a new role for this user updatedRolesSet.Add(RoleService.GetRole(roleStr)); } } // Replace the roles in the user's collection user.Roles.Clear(); foreach (var role in updatedRolesSet) { user.Roles.Add(role); } }
public IPagedList<PrivateMessageListItem> GetUsersPrivateMessages(int pageIndex, int pageSize, MembershipUser user) { var query = _context.PrivateMessage .AsNoTracking() .Include(x => x.UserFrom) .Include(x => x.UserTo) .Where(x => (x.UserTo.Id == user.Id && x.IsSentMessage != true) || (x.UserFrom.Id == user.Id && x.IsSentMessage == true)) .Select(x => new PrivateMessageListItem { Date = x.DateSent, User = (x.IsSentMessage == true ? x.UserTo : x.UserFrom), HasUnreadMessages = (x.IsSentMessage != true && x.UserFrom.Id != user.Id && (x.IsRead == false)) }) .GroupBy(x => x.User.Id) .Select(x => x.OrderByDescending(d => d.Date).FirstOrDefault()) .OrderByDescending(x => x.Date); var total = query.Count(); var results = query .Skip((pageIndex - 1) * pageSize) .Take(pageSize) .ToList(); // Return a paged list return new PagedList<PrivateMessageListItem>(results, pageIndex, pageSize, total); }
public void AddPost() { var postRepository = Substitute.For<IPostRepository>(); var topicRepository = Substitute.For<ITopicRepository>(); var roleService = Substitute.For<IRoleService>(); var membershipUserPointsService = Substitute.For<IMembershipUserPointsService>(); var settingsService = Substitute.For<ISettingsService>(); settingsService.GetSettings().Returns(new Settings { PointsAddedPerPost = 20 }); var localisationService = Substitute.For<ILocalizationService>(); var postService = new PostService(membershipUserPointsService, settingsService, roleService, postRepository, topicRepository, localisationService, _api); var category = new Category(); var role = new MembershipRole{RoleName = "TestRole"}; var categoryPermissionForRoleSet = new List<CategoryPermissionForRole> { new CategoryPermissionForRole { Permission = new Permission { Name = AppConstants.PermissionEditPosts }, IsTicked = true}, new CategoryPermissionForRole { Permission = new Permission { Name = AppConstants.PermissionDenyAccess }, IsTicked = false}, new CategoryPermissionForRole { Permission = new Permission { Name = AppConstants.PermissionReadOnly }, IsTicked = false} }; var permissionSet = new PermissionSet(categoryPermissionForRoleSet); roleService.GetPermissions(category, role).Returns(permissionSet); var topic = new Topic { Name = "Captain America", Category = category}; var user = new MembershipUser { UserName = "******", Roles = new List<MembershipRole>{role} }; var newPost = postService.AddNewPost("A test post", topic, user, out permissionSet); Assert.AreEqual(newPost.User, user); Assert.AreEqual(newPost.Topic, topic); }
//public IPagedList<PrivateMessage> GetPagedSentMessagesByUser(int pageIndex, int pageSize, MembershipUser user) //{ // var totalCount = _context.PrivateMessage // .Include(x => x.UserTo) // .Include(x => x.UserFrom) // .Count(x => x.UserFrom.Id == user.Id && x.IsSentMessage == true); // // Get the topics using an efficient // var results = _context.PrivateMessage // .Include(x => x.UserTo) // .Include(x => x.UserFrom) // .Where(x => x.UserFrom.Id == user.Id) // .Where(x => x.IsSentMessage == true) // .OrderByDescending(x => x.DateSent) // .Skip((pageIndex - 1) * pageSize) // .Take(pageSize) // .ToList(); // // Return a paged list // return new PagedList<PrivateMessage>(results, pageIndex, pageSize, totalCount); //} //public IPagedList<PrivateMessage> GetPagedReceivedMessagesByUser(int pageIndex, int pageSize, MembershipUser user) //{ // var totalCount = _context.PrivateMessage // .Include(x => x.UserTo) // .Include(x => x.UserFrom) // .OrderByDescending(x => x.DateSent) // .Count(x => (x.UserTo.Id == user.Id || x.UserFrom.Id == user.Id) && x.IsSentMessage != true); // var results = _context.PrivateMessage // .Include(x => x.UserTo) // .Include(x => x.UserFrom) // .OrderByDescending(x => x.DateSent) // .Where(x => (x.UserTo.Id == user.Id || x.UserFrom.Id == user.Id) && x.IsSentMessage != true) // .Skip((pageIndex - 1) * pageSize) // .Take(pageSize) // .ToList(); // // Return a paged list // return new PagedList<PrivateMessage>(results, pageIndex, pageSize, totalCount); //} public IPagedList<PrivateMessageListItem> GetUsersPrivateMessages(int pageIndex, int pageSize, MembershipUser user) { //TODO - Need to rework this as it's not very efficient // Get all received pms var members = user.PrivateMessagesReceived.Where(x => x.IsSentMessage == true).OrderByDescending(x => x.DateSent).DistinctBy(x => x.UserFrom.Id).Select(x => new PrivateMessageListItem { Date = x.DateSent, User = x.UserFrom }).ToList(); // Get all sent pms + ISSent var sentToMembers = user.PrivateMessagesSent.Where(x => x.IsSentMessage != true).OrderByDescending(x => x.DateSent).DistinctBy(x => x.UserTo.Id).Select(x => new PrivateMessageListItem { Date = x.DateSent, User = x.UserTo }).ToList(); // Add lists members.AddRange(sentToMembers); // Get the full amount var uniqueMembers = members.OrderByDescending(x => x.Date).DistinctBy(x => x.User.Id).ToList(); var uniqueMembersCount = uniqueMembers.Count; // Now distinct the lists again members = uniqueMembers.Skip((pageIndex - 1) * pageSize) .Take(pageSize) .ToList(); // Return a paged list return new PagedList<PrivateMessageListItem>(members, pageIndex, pageSize, uniqueMembersCount); }
public bool Rule(MembershipUser user, IMVCForumAPI api) { //Post is marked as the answer to a topic - give the post author a badge var usersSolutions = api.Post.GetSolutionsWrittenByMember(user.Id); return (usersSolutions.Count >= 1); }
public bool Rule(MembershipUser user) { //Post is marked as the answer to a topic - give the post author a badge var postService = DependencyResolver.Current.GetService<IPostService>(); var usersSolutions = postService.GetSolutionsByMember(user.Id); return (usersSolutions.Count >= 10); }
/// <summary> /// Add a new post /// </summary> /// <param name="postContent"> </param> /// <param name="topic"> </param> /// <param name="user"></param> /// <param name="permissions"> </param> /// <returns>True if post added</returns> public Post AddNewPost(string postContent, Topic topic, MembershipUser user, out PermissionSet permissions) { // Get the permissions for the category that this topic is in permissions = _roleService.GetPermissions(topic.Category, UsersRole(user)); // Check this users role has permission to create a post if (permissions[AppConstants.PermissionDenyAccess].IsTicked || permissions[AppConstants.PermissionReadOnly].IsTicked) { // Throw exception so Ajax caller picks it up throw new ApplicationException(_localizationService.GetResourceString("Errors.NoPermission")); } // Has permission so create the post var newPost = new Post { PostContent = postContent, User = user, Topic = topic, IpAddress = StringUtils.GetUsersIpAddress(), DateCreated = DateTime.UtcNow, DateEdited = DateTime.UtcNow }; // Sort the search field out var category = topic.Category; if (category.ModeratePosts == true) { newPost.Pending = true; } var e = new PostMadeEventArgs { Post = newPost }; EventManager.Instance.FireBeforePostMade(this, e); if (!e.Cancel) { // create the post Add(newPost); // Update the users points score and post count for posting _membershipUserPointsService.Add(new MembershipUserPoints { Points = _settingsService.GetSettings().PointsAddedPerPost, User = user, PointsFor = PointsFor.Post, PointsForId = newPost.Id }); // add the last post to the topic topic.LastPost = newPost; EventManager.Instance.FireAfterPostMade(this, new PostMadeEventArgs { Post = newPost }); return newPost; } return newPost; }
public void Delete(MembershipUser user, PointsFor type, Guid referenceId) { var mp = _context.MembershipUserPoints.Where( x => x.User.Id == user.Id && x.PointsFor == type && x.PointsForId == referenceId); var mpoints = new List<MembershipUserPoints>(); mpoints.AddRange(mp); Delete(mpoints); }
public bool Rule(MembershipUser user) { var lastPost = user.Posts.OrderByDescending(x => x.DateCreated).FirstOrDefault(); if (lastPost != null && lastPost.PostContent.ToLower().Contains("umbraco")) { return true; } return false; }
/// <summary> /// Return notifications for a specified user and category /// </summary> /// <param name="user"></param> /// <param name="category"></param> /// <param name="addTracking"></param> /// <returns></returns> public IList<CategoryNotification> GetByUserAndCategory(MembershipUser user, Category category, bool addTracking = false) { var notifications = _context.CategoryNotification .Where(x => x.Category.Id == category.Id && x.User.Id == user.Id); if (addTracking) { return notifications.ToList(); } return notifications.AsNoTracking().ToList(); }
public MembershipUser Create(string name) { var newUser = new MembershipUser { UserName = name }; // Id is created by API return _api.Member.Create(newUser); }
public PrivateMessageController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, IPrivateMessageService privateMessageService, IEmailService emailService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _privateMessageService = privateMessageService; _emailService = emailService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; }
public IList<TagNotification> GetByUserAndTag(MembershipUser user, TopicTag tag, bool addTracking = false) { var notifications = _context.TagNotification .Where(x => x.User.Id == user.Id && x.Tag.Id == tag.Id); if (addTracking) { return notifications.ToList(); } return notifications.AsNoTracking().ToList(); }
public IEnumerable<MembershipUserPoints> GetByUser(MembershipUser user, bool removeTracking = true) { var users = _context.MembershipUserPoints .Where(x => x.User.Id == user.Id); if (removeTracking) { return users.AsNoTracking(); } return users; }
private void MarkPostUpOrDown(Post post, MembershipUser postWriter, MembershipUser voter, PostType postType) { var settings = SettingsService.GetSettings(); // Check this user is not the post owner if (voter.Id != postWriter.Id) { // Not the same person, now check they haven't voted on this post before var votes = post.Votes.Where(x => x.VotedByMembershipUser.Id == LoggedOnReadOnlyUser.Id).ToList(); if (votes.Any()) { // Already voted, so delete the vote and remove the points var votesToDelete = new List <Vote>(); votesToDelete.AddRange(votes); foreach (var vote in votesToDelete) { _voteService.Delete(vote); } // Update the post with the new points amount var newPointTotal = (postType == PostType.Negative) ? (post.VoteCount + 1) : (post.VoteCount - 1); post.VoteCount = newPointTotal; } else { // Points to add or subtract to a user var usersPoints = (postType == PostType.Negative) ? (-settings.PointsDeductedNagativeVote) : (settings.PointsAddedPostiveVote); // Update the post with the new vote of the voter var vote = new Vote { Post = post, User = postWriter, Amount = (postType == PostType.Negative) ? (-1) : (1), VotedByMembershipUser = voter, DateVoted = DateTime.UtcNow }; _voteService.Add(vote); // Update the users points who wrote the post _membershipUserPointsService.Add(new MembershipUserPoints { Points = usersPoints, User = postWriter, PointsFor = PointsFor.Vote, PointsForId = vote.Id }); // Update the post with the new points amount var newPointTotal = (postType == PostType.Negative) ? (post.VoteCount - 1) : (post.VoteCount + 1); post.VoteCount = newPointTotal; } } }
public void MemberJoinedActivityAdd() { const string guidStr = "515b7240-3be1-43d4-8846-c0b589cd1cd2"; var activityRepository = Substitute.For<IActivityRepository>(); IActivityService activityService = new ActivityService(activityRepository, _badgeRepository, _membershipRepository, _loggingService); var user = new MembershipUser { Id = new Guid(guidStr), UserName = "******" }; activityService.MemberJoined(user); activityRepository.Received().Add((Arg.Is<Activity>(x => x.Data == MemberJoinedActivity.KeyUserId + "=" + guidStr))); }
public bool Rule(MembershipUser user) { //Post is marked as the answer to a topic - give the post author a badge // Get all categories as we want to check all the members solutions, even across // categories that he no longer is allowed to access var cats = _categoryService.GetAll(); var usersSolutions = _postService.GetSolutionsByMember(user.Id, cats); return (usersSolutions.Count >= 1); }
/// <summary> /// Constructor /// </summary> /// <param name="loggingService"> </param> /// <param name="unitOfWorkManager"> </param> /// <param name="membershipService"></param> /// <param name="localizationService"> </param> /// <param name="settingsService"> </param> public BaseAdminController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, ISettingsService settingsService) { UnitOfWorkManager = unitOfWorkManager; MembershipService = membershipService; LocalizationService = localizationService; LocalizationService.CurrentLanguage = LocalizationService.DefaultLanguage; SettingsService = settingsService; LoggingService = loggingService; LoggedOnReadOnlyUser = MembershipService.GetUser(System.Web.HttpContext.Current.User.Identity.Name, true); }
public HomeController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IActivityService activityService, IMembershipService membershipService, ITopicService topicService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _topicService = topicService; _activityService = activityService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; UsersRole = LoggedOnUser == null ? RoleService.GetRole(AppConstants.GuestRoleName) : LoggedOnUser.Roles.FirstOrDefault(); }
public UploadController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, IPostService postService, IUploadedFileService uploadedFileService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _postService = postService; _uploadedFileService = uploadedFileService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; UsersRole = LoggedOnUser == null ? RoleService.GetRole(AppConstants.GuestRoleName) : LoggedOnUser.Roles.FirstOrDefault(); }
public PollController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, IPollService pollService, IPollVoteService pollVoteService, IPollAnswerService pollAnswerService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _pollService = pollService; _pollAnswerService = pollAnswerService; _pollVoteService = pollVoteService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; }
//private readonly MembershipUser _loggedInUser; /// <summary> /// Constructor /// </summary> /// <param name="loggingService"> </param> /// <param name="unitOfWorkManager"> </param> /// <param name="membershipService"></param> /// <param name="localizationService"> </param> /// <param name="roleService"> </param> /// <param name="settingsService"> </param> public BaseController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService) { UnitOfWorkManager = unitOfWorkManager; MembershipService = membershipService; LocalizationService = localizationService; RoleService = roleService; SettingsService = settingsService; LoggingService = loggingService; LoggedOnReadOnlyUser = UserIsAuthenticated ? MembershipService.GetUser(Username, true) : null; UsersRole = LoggedOnReadOnlyUser == null ? RoleService.GetRole(AppConstants.GuestRoleName, true) : LoggedOnReadOnlyUser.Roles.FirstOrDefault(); }
public static SingleMemberListViewModel UserToSingleMemberListViewModel(MembershipUser user) { var viewModel = new SingleMemberListViewModel { IsApproved = user.IsApproved, Id = user.Id, IsLockedOut = user.IsLockedOut, Roles = user.Roles.Select(x => x.RoleName).ToArray(), UserName = user.UserName }; return viewModel; }
public EmailController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, ITopicNotificationService topicNotificationService, ICategoryNotificationService categoryNotificationService, ICategoryService categoryService, ITopicService topicService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _topicNotificationService = topicNotificationService; _categoryNotificationService = categoryNotificationService; _categoryService = categoryService; _topicService = topicService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; }
/// <summary> /// Add a new post /// </summary> /// <param name="postContent"> </param> /// <param name="topic"> </param> /// <param name="user"></param> /// <param name="permissions"> </param> /// <returns>True if post added</returns> public Post AddNewPost(string postContent, Topic topic, MembershipUser user, out PermissionSet permissions) { // Get the permissions for the category that this topic is in permissions = _roleService.GetPermissions(topic.Category, UsersRole(user)); // Check this users role has permission to create a post if (permissions[AppConstants.PermissionDenyAccess].IsTicked || permissions[AppConstants.PermissionReadOnly].IsTicked) { // Throw exception so Ajax caller picks it up throw new ApplicationException(_localizationService.GetResourceString("Errors.NoPermission")); } // Has permission so create the post var newPost = new Post { PostContent = postContent, User = user, Topic = topic, IpAddress = StringUtils.GetUsersIpAddress() }; newPost = SanitizePost(newPost); var e = new PostMadeEventArgs { Post = newPost, Api = _api }; EventManager.Instance.FireBeforePostMade(this, e); if (!e.Cancel) { // create the post Add(newPost); // Update the users points score and post count for posting _membershipUserPointsService.Add(new MembershipUserPoints { Points = _settingsService.GetSettings().PointsAddedPerPost, User = user }); // add the last post to the topic topic.LastPost = newPost; // Removed as its updated via the commit //_topicRepository.Update(topic); EventManager.Instance.FireAfterPostMade(this, new PostMadeEventArgs { Post = newPost, Api = _api }); return newPost; } return newPost; }
public MembersController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, IPostService postService, IReportService reportService, IEmailService emailService, IPrivateMessageService privateMessageService, IBannedEmailService bannedEmailService, IBannedWordService bannedWordService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _postService = postService; _reportService = reportService; _emailService = emailService; _privateMessageService = privateMessageService; _bannedEmailService = bannedEmailService; _bannedWordService = bannedWordService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; UsersRole = LoggedOnUser == null ? RoleService.GetRole(AppConstants.GuestRoleName) : LoggedOnUser.Roles.FirstOrDefault(); }
public void BadgeAwardedActivityAdd() { const string guidStrBadge = "515b7240-3be1-43d4-8846-c0b589cd1cd2"; const string guidStrUser = "******"; var activityRepository = Substitute.For<IActivityRepository>(); IActivityService activityService = new ActivityService(activityRepository, _badgeRepository, _membershipRepository, _loggingService); var user = new MembershipUser { Id = new Guid(guidStrUser), UserName = "******" }; var badge = new Badge { Id = new Guid(guidStrBadge) }; activityService.BadgeAwarded(badge, user, DateTime.UtcNow); activityRepository.Received().Add((Arg.Is<Activity>(x => x.Data == BadgeActivity.KeyBadgeId + "=" + guidStrBadge + "," + BadgeActivity.KeyUserId + "=" + guidStrUser))); }
/// <summary> /// Maps the posts for a specific topic /// </summary> /// <param name="posts"></param> /// <param name="votes"></param> /// <param name="permission"></param> /// <param name="topic"></param> /// <param name="loggedOnUser"></param> /// <param name="settings"></param> /// <param name="favourites"></param> /// <returns></returns> public static List<PostViewModel> CreatePostViewModels(IEnumerable<Post> posts, List<Vote> votes, PermissionSet permission, Topic topic, MembershipUser loggedOnUser, Settings settings, List<Favourite> favourites) { var viewModels = new List<PostViewModel>(); var groupedVotes = votes.ToLookup(x => x.Post.Id); var groupedFavourites = favourites.ToLookup(x => x.Post.Id); foreach (var post in posts) { var id = post.Id; var postVotes = (groupedVotes.Contains(id) ? groupedVotes[id].ToList() : new List<Vote>()); var postFavs = (groupedFavourites.Contains(id) ? groupedFavourites[id].ToList() : new List<Favourite>()); viewModels.Add(CreatePostViewModel(post, postVotes, permission, topic, loggedOnUser, settings, postFavs)); } return viewModels; }
private bool ProcessSocialLogonUser(MembershipUser user, bool doCommit) { // Secondly see if the email is banned if (_bannedEmailService.EmailIsBanned(user.Email)) { doCommit = false; TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel { Message = LocalizationService.GetResourceString("Error.EmailIsBanned"), MessageType = GenericMessages.error }; } else { // Check not already someone with that user name, if so append count var exists = MembershipService.GetUser(user.UserName); if (exists != null) { var howMany = MembershipService.SearchMembers(user.UserName, int.MaxValue); user.UserName = string.Format("{0} ({1})", user.UserName, howMany != null ? howMany.Count : 1); } // Now check settings, see if users need to be manually authorised var manuallyAuthoriseMembers = SettingsService.GetSettings().ManuallyAuthoriseNewMembers; var memberEmailAuthorisationNeeded = SettingsService.GetSettings().NewMemberEmailConfirmation ?? false; if (manuallyAuthoriseMembers || memberEmailAuthorisationNeeded) { user.IsApproved = false; } var createStatus = MembershipService.CreateUser(user); if (createStatus != MembershipCreateStatus.Success) { doCommit = false; TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel { Message = MembershipService.ErrorCodeToString(createStatus), MessageType = GenericMessages.error }; } else { // Set the view bag message here SetRegisterViewBagMessage(manuallyAuthoriseMembers, memberEmailAuthorisationNeeded, user); } } return doCommit; }
public SearchController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, IPostService postService, ITopicService topicService, IVoteService voteService, IFavouriteService favouriteService, ICategoryService categoryService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _postService = postService; _topicsService = topicService; _voteService = voteService; _favouriteService = favouriteService; _categoryService = categoryService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; UsersRole = LoggedOnUser == null ? RoleService.GetRole(AppConstants.GuestRoleName) : LoggedOnUser.Roles.FirstOrDefault(); }
/// <summary> /// Constructor /// </summary> /// <param name="loggingService"> </param> /// <param name="unitOfWorkManager"> </param> /// <param name="membershipService"></param> /// <param name="localizationService"> </param> /// <param name="roleService"> </param> /// <param name="settingsService"> </param> public BaseController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService) { UnitOfWorkManager = unitOfWorkManager; MembershipService = membershipService; LocalizationService = localizationService; RoleService = roleService; SettingsService = settingsService; LoggingService = loggingService; using (UnitOfWorkManager.NewUnitOfWork()) { LoggedOnReadOnlyUser = UserIsAuthenticated ? MembershipService.GetUser(Username, true) : null; UsersRole = LoggedOnReadOnlyUser == null?RoleService.GetRole(AppConstants.GuestRoleName, true) : LoggedOnReadOnlyUser.Roles.FirstOrDefault(); } }
public VoteController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, IPostService postService, IVoteService voteService, ISettingsService settingsService, ITopicService topicService, IMembershipUserPointsService membershipUserPointsService, IBadgeService badgeService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _postService = postService; _voteService = voteService; _topicService = topicService; _membershipUserPointsService = membershipUserPointsService; _badgeService = badgeService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; }
public TopicController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, IRoleService roleService, ITopicService topicService, IPostService postService, ICategoryService categoryService, ILocalizationService localizationService, ISettingsService settingsService, ITopicTagService topicTagService, IMembershipUserPointsService membershipUserPointsService, ICategoryNotificationService categoryNotificationService, IEmailService emailService, ITopicNotificationService topicNotificationService, ILuceneService luceneService, IPollService pollService, IPollAnswerService pollAnswerService, IBannedWordService bannedWordService) : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService) { _topicService = topicService; _postService = postService; _categoryService = categoryService; _topicTagService = topicTagService; _membershipUserPointsService = membershipUserPointsService; _categoryNotificationService = categoryNotificationService; _emailService = emailService; _topicNotificationService = topicNotificationService; _luceneService = luceneService; _pollService = pollService; _pollAnswerService = pollAnswerService; _bannedWordService = bannedWordService; LoggedOnUser = UserIsAuthenticated ? MembershipService.GetUser(Username) : null; UsersRole = LoggedOnUser == null?RoleService.GetRole(AppConstants.GuestRoleName) : LoggedOnUser.Roles.FirstOrDefault(); }
/// <summary> /// Take a set of role names and update a user's collection of roles accordingly /// </summary> /// <param name="user"></param> /// <param name="updatedRoles"></param> private void UpdateUserRoles(MembershipUser user, IEnumerable <string> updatedRoles) { // --------------------------------------------------------------------- // IMPORTANT - If you call this it MUST be within a unit of work // --------------------------------------------------------------------- // Not done in automapper to avoid handling services in the mapper var updatedRolesSet = new List <MembershipRole>(); foreach (var roleStr in updatedRoles) { var alreadyIsRoleForUser = false; foreach (var role in user.Roles) { if (roleStr == role.RoleName) { // This role for this user is UNchanged updatedRolesSet.Add(role); alreadyIsRoleForUser = true; break; } } if (!alreadyIsRoleForUser) { // This is a new role for this user updatedRolesSet.Add(_roleService.GetRole(roleStr)); } } // Replace the roles in the user's collection user.Roles.Clear(); foreach (var role in updatedRolesSet) { user.Roles.Add(role); } }
private void DeleteUsersPostsPollsVotesAndPoints(MembershipUser user, IUnitOfWork unitOfWork) { // Delete all file uploads var files = _uploadedFileService.GetAllByUser(user.Id); var filesList = new List <UploadedFile>(); filesList.AddRange(files); foreach (var file in filesList) { // store the file path as we'll need it to delete on the file system var filePath = file.FilePath; // Now delete it _uploadedFileService.Delete(file); // And finally delete from the file system System.IO.File.Delete(Server.MapPath(filePath)); } // Delete all posts var posts = user.Posts; var postList = new List <Post>(); postList.AddRange(posts); foreach (var post in postList) { post.Files.Clear(); _postService.Delete(post); } unitOfWork.SaveChanges(); // Also clear their poll votes var userPollVotes = user.PollVotes; if (userPollVotes.Any()) { var pollList = new List <PollVote>(); pollList.AddRange(userPollVotes); foreach (var vote in pollList) { vote.User = null; _pollVoteService.Delete(vote); } user.PollVotes.Clear(); } unitOfWork.SaveChanges(); // Also clear their polls var userPolls = user.Polls; if (userPolls.Any()) { var polls = new List <Poll>(); polls.AddRange(userPolls); foreach (var poll in polls) { //Delete the poll answers var pollAnswers = poll.PollAnswers; if (pollAnswers.Any()) { var pollAnswersList = new List <PollAnswer>(); pollAnswersList.AddRange(pollAnswers); foreach (var answer in pollAnswersList) { answer.Poll = null; _pollAnswerService.Delete(answer); } } poll.PollAnswers.Clear(); poll.User = null; _pollService.Delete(poll); } user.Polls.Clear(); } unitOfWork.SaveChanges(); // Delete all topics var topics = user.Topics; var topicList = new List <Topic>(); topicList.AddRange(topics); foreach (var topic in topicList) { _topicService.Delete(topic); } // Also clear their points var userPoints = user.Points; if (userPoints.Any()) { var pointsList = new List <MembershipUserPoints>(); pointsList.AddRange(userPoints); foreach (var point in pointsList) { point.User = null; _membershipUserPointsService.Delete(point); } user.Points.Clear(); } unitOfWork.SaveChanges(); // Now clear all activities for this user var usersActivities = _activityService.GetDataFieldByGuid(user.Id); _activityService.Delete(usersActivities.ToList()); }
private HttpResponseMessage MemberRegisterLogic(MemberAddViewModel userModel) { using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork()) { var userToSave = new MVCForum.Domain.DomainModel.MembershipUser { UserName = _bannedWordService.SanitiseBannedWords(userModel.UserName), Email = userModel.Email, Password = userModel.Password, IsApproved = userModel.IsApproved, Comment = userModel.Comment, UniversalId = userModel.UniversalId }; var createStatus = _membershipService.CreateUser(userToSave); if (createStatus != MVCForum.Domain.DomainModel.MembershipCreateStatus.Success) { ModelState.AddModelError(string.Empty, _membershipService.ErrorCodeToString(createStatus)); return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } else { // See if this is a social login and we have their profile pic if (!string.IsNullOrWhiteSpace(userModel.SocialProfileImageUrl)) { // We have an image url - Need to save it to their profile var image = AppHelpers.GetImageFromExternalUrl(userModel.SocialProfileImageUrl); // Set upload directory - Create if it doesn't exist var uploadFolderPath = HostingEnvironment.MapPath(string.Concat(SiteConstants.UploadFolderPath, userToSave.Id)); if (!Directory.Exists(uploadFolderPath)) { Directory.CreateDirectory(uploadFolderPath); } // Get the file name var fileName = Path.GetFileName(userModel.SocialProfileImageUrl); // Create a HttpPostedFileBase image from the C# Image using (var stream = new MemoryStream()) { image.Save(stream, ImageFormat.Jpeg); stream.Position = 0; HttpPostedFileBase formattedImage = new MemoryFile(stream, "image/jpeg", fileName); // Upload the file var uploadResult = AppHelpers.UploadFile(formattedImage, uploadFolderPath, LocalizationService); // Don't throw error if problem saving avatar, just don't save it. if (uploadResult.UploadSuccessful) { userToSave.Avatar = uploadResult.UploadedFileName; } } } // Store access token for social media account in case we want to do anything with it if (userModel.LoginType == LoginType.Facebook) { userToSave.FacebookAccessToken = userModel.UserAccessToken; } if (userModel.LoginType == LoginType.Google) { userToSave.GoogleAccessToken = userModel.UserAccessToken; } if (userModel.Roles != null && userModel.Roles.Any()) { UpdateUserRoles(userToSave, userModel.Roles); } try { userToSave.IsApproved = userModel.IsApproved; unitOfWork.Commit(); return(Request.CreateResponse(HttpStatusCode.OK, userToSave.Id)); } catch (Exception ex) { unitOfWork.Rollback(); LoggingService.Error(ex); FormsAuthentication.SignOut(); ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.GenericMessage")); return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } } } }