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;
}
}
}
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 ActionResult MemberRegisterLogic(MemberAddViewModel userModel)
{
using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
{
var settings = SettingsService.GetSettings();
var manuallyAuthoriseMembers = settings.ManuallyAuthoriseNewMembers;
var memberEmailAuthorisationNeeded = settings.NewMemberEmailConfirmation == true;
var homeRedirect = false;
var userToSave = new MembershipUser
{
UserName = _bannedWordService.SanitiseBannedWords(userModel.UserName),
Email = userModel.Email,
Password = userModel.Password,
IsApproved = userModel.IsApproved,
Comment = userModel.Comment,
};
var createStatus = MembershipService.CreateUser(userToSave);
if (createStatus != MembershipCreateStatus.Success)
{
ModelState.AddModelError(string.Empty, MembershipService.ErrorCodeToString(createStatus));
}
else
{
// See if this is a social login and we have their profile pic
if (!string.IsNullOrEmpty(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.Instance.UploadFolderPath, userToSave.Id));
if (uploadFolderPath != null && !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())
{
// Microsoft doesn't give you a file extension - See if it has a file extension
// Get the file extension
var fileExtension = Path.GetExtension(fileName);
// Fix invalid Illegal charactors
var regexSearch = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());
var reg = new Regex($"[{Regex.Escape(regexSearch)}]");
fileName = reg.Replace(fileName, "");
if (string.IsNullOrEmpty(fileExtension))
{
// no file extension so give it one
fileName = string.Concat(fileName, ".jpg");
}
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, true);
// 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
var isSocialLogin = false;
if (userModel.LoginType == LoginType.Facebook)
{
userToSave.FacebookAccessToken = userModel.UserAccessToken;
isSocialLogin = true;
}
if (userModel.LoginType == LoginType.Google)
{
userToSave.GoogleAccessToken = userModel.UserAccessToken;
isSocialLogin = true;
}
if (userModel.LoginType == LoginType.Microsoft)
{
userToSave.MicrosoftAccessToken = userModel.UserAccessToken;
isSocialLogin = true;
}
// If this is a social login, and memberEmailAuthorisationNeeded is true then we need to ignore it
// and set memberEmailAuthorisationNeeded to false because the email addresses are validated by the social media providers
if (isSocialLogin && !manuallyAuthoriseMembers)
{
memberEmailAuthorisationNeeded = false;
userToSave.IsApproved = true;
}
// Set the view bag message here
SetRegisterViewBagMessage(manuallyAuthoriseMembers, memberEmailAuthorisationNeeded, userToSave);
if (!manuallyAuthoriseMembers && !memberEmailAuthorisationNeeded)
{
homeRedirect = true;
}
try
{
// Only send the email if the admin is not manually authorising emails or it's pointless
SendEmailConfirmationEmail(userToSave);
unitOfWork.Commit();
if (homeRedirect)
{
if (Url.IsLocalUrl(userModel.ReturnUrl) && userModel.ReturnUrl.Length > 1 && userModel.ReturnUrl.StartsWith("/")
&& !userModel.ReturnUrl.StartsWith("//") && !userModel.ReturnUrl.StartsWith("/\\"))
{
return Redirect(userModel.ReturnUrl);
}
return RedirectToAction("Index", "Home", new { area = string.Empty });
}
}
catch (Exception ex)
{
unitOfWork.Rollback();
LoggingService.Error(ex);
FormsAuthentication.SignOut();
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.GenericMessage"));
}
}
}
return View("Register");
}
public ActionResult LogOn(LogOnViewModel model)
{
using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
{
var username = model.UserName;
var password = model.Password;
try
{
if (ModelState.IsValid)
{
// We have an event here to help with Single Sign Ons
// You can do manual lookups to check users based on a webservice and validate a user
// Then log them in if they exist or create them and log them in - Have passed in a UnitOfWork
// To allow database changes.
var e = new LoginEventArgs
{
UserName = model.UserName,
Password = model.Password,
RememberMe = model.RememberMe,
ReturnUrl = model.ReturnUrl,
UnitOfWork = unitOfWork
};
EventManager.Instance.FireBeforeLogin(this, e);
if (!e.Cancel)
{
var message = new GenericMessageViewModel();
var user = new MembershipUser();
if (MembershipService.ValidateUser(username, password, Membership.MaxInvalidPasswordAttempts))
{
// Set last login date
user = MembershipService.GetUser(username);
if (user.IsApproved && !user.IsLockedOut && !user.IsBanned)
{
FormsAuthentication.SetAuthCookie(username, model.RememberMe);
user.LastLoginDate = DateTime.UtcNow;
if (Url.IsLocalUrl(model.ReturnUrl) && model.ReturnUrl.Length > 1 && model.ReturnUrl.StartsWith("/")
&& !model.ReturnUrl.StartsWith("//") && !model.ReturnUrl.StartsWith("/\\"))
{
return Redirect(model.ReturnUrl);
}
message.Message = LocalizationService.GetResourceString("Members.NowLoggedIn");
message.MessageType = GenericMessages.success;
EventManager.Instance.FireAfterLogin(this, new LoginEventArgs
{
UserName = model.UserName,
Password = model.Password,
RememberMe = model.RememberMe,
ReturnUrl = model.ReturnUrl,
UnitOfWork = unitOfWork
});
return RedirectToAction("Index", "Home", new { area = string.Empty });
}
//else if (!user.IsApproved && SettingsService.GetSettings().ManuallyAuthoriseNewMembers)
//{
// message.Message = LocalizationService.GetResourceString("Members.NowRegisteredNeedApproval");
// message.MessageType = GenericMessages.success;
//}
//else if (!user.IsApproved && SettingsService.GetSettings().NewMemberEmailConfirmation == true)
//{
// message.Message = LocalizationService.GetResourceString("Members.MemberEmailAuthorisationNeeded");
// message.MessageType = GenericMessages.success;
//}
}
// Only show if we have something to actually show to the user
if (!string.IsNullOrEmpty(message.Message))
{
TempData[AppConstants.MessageViewBagName] = message;
}
else
{
// get here Login failed, check the login status
var loginStatus = MembershipService.LastLoginStatus;
switch (loginStatus)
{
case LoginAttemptStatus.UserNotFound:
case LoginAttemptStatus.PasswordIncorrect:
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Members.Errors.PasswordIncorrect"));
break;
case LoginAttemptStatus.PasswordAttemptsExceeded:
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Members.Errors.PasswordAttemptsExceeded"));
break;
case LoginAttemptStatus.UserLockedOut:
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Members.Errors.UserLockedOut"));
break;
case LoginAttemptStatus.Banned:
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Members.NowBanned"));
break;
case LoginAttemptStatus.UserNotApproved:
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Members.Errors.UserNotApproved"));
user = MembershipService.GetUser(username);
SendEmailConfirmationEmail(user);
break;
default:
ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Members.Errors.LogonGeneric"));
break;
}
}
}
}
}
finally
{
try
{
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
LoggingService.Error(ex);
}
}
return View(model);
}
}
private void SetRegisterViewBagMessage(bool manuallyAuthoriseMembers, bool memberEmailAuthorisationNeeded, MembershipUser userToSave)
{
if (manuallyAuthoriseMembers)
{
TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel
{
Message = LocalizationService.GetResourceString("Members.NowRegisteredNeedApproval"),
MessageType = GenericMessages.success
};
}
else if (memberEmailAuthorisationNeeded)
{
TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel
{
Message = LocalizationService.GetResourceString("Members.MemberEmailAuthorisationNeeded"),
MessageType = GenericMessages.success
};
}
else
{
// If not manually authorise then log the user in
if (SiteConstants.Instance.AutoLoginAfterRegister)
{
FormsAuthentication.SetAuthCookie(userToSave.UserName, false);
}
TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel
{
Message = LocalizationService.GetResourceString("Members.NowRegistered"),
MessageType = GenericMessages.success
};
}
}
private void SendEmailConfirmationEmail(MembershipUser userToSave)
{
var settings = SettingsService.GetSettings();
var manuallyAuthoriseMembers = settings.ManuallyAuthoriseNewMembers;
var memberEmailAuthorisationNeeded = settings.NewMemberEmailConfirmation == true;
if (manuallyAuthoriseMembers == false && memberEmailAuthorisationNeeded)
{
if (!string.IsNullOrEmpty(userToSave.Email))
{
// SEND AUTHORISATION EMAIL
var sb = new StringBuilder();
var confirmationLink = string.Concat(StringUtils.ReturnCurrentDomain(), Url.Action("EmailConfirmation", new { id = userToSave.Id }));
sb.AppendFormat("<p>{0}</p>", string.Format(LocalizationService.GetResourceString("Members.MemberEmailAuthorisation.EmailBody"),
settings.ForumName,
string.Format("<p><a href=\"{0}\">{0}</a></p>", confirmationLink)));
var email = new Email
{
EmailTo = userToSave.Email,
NameTo = userToSave.UserName,
Subject = LocalizationService.GetResourceString("Members.MemberEmailAuthorisation.Subject")
};
email.Body = _emailService.EmailTemplate(email.NameTo, sb.ToString());
_emailService.SendMail(email);
// ADD COOKIE
// We add a cookie for 7 days, which will display the resend email confirmation button
// This cookie is removed when they click the confirmation link
var myCookie = new HttpCookie(AppConstants.MemberEmailConfirmationCookieName)
{
Value = $"{userToSave.Email}#{userToSave.UserName}",
Expires = DateTime.UtcNow.AddDays(7)
};
// Add the cookie.
Response.Cookies.Add(myCookie);
}
}
}
private static MemberFrontEndEditViewModel PopulateMemberViewModel(MembershipUser user)
{
var viewModel = new MemberFrontEndEditViewModel
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email,
Signature = user.Signature,
Age = user.Age,
Location = user.Location,
Website = user.Website,
Twitter = user.Twitter,
Facebook = user.Facebook,
DisableFileUploads = user.DisableFileUploads == true,
Avatar = user.Avatar,
DisableEmailNotifications = user.DisableEmailNotifications == true,
AmountOfPoints = user.TotalPoints
};
return viewModel;
}
