public async Task <IActionResult> RegisterAsync(RegisterViewModel vm)
{
if (ModelState.IsValid)
{
var user = new AppUser
{
UserName = vm.Email,
Email = vm.Email,
TimeZone = vm.TimeZone
};
var result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var appLink = Url.Action(nameof(Login), "Account", null, HttpContext.Request.Scheme);
var response = await _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = user.Email,
Subject = Constants.SubjectRegistrationEmail
}, Constants.TitleRegistrationEmail, Constants.ContentRegistrationEmail,
Constants.ButtonVisitSide,
appLink);
if (response.Successful)
{
return(RedirectToAction(nameof(StartController.Index), "Start"));
}
TempData["ErrorMessage"] = Constants.GeneralSendEmailErrorMessage;
foreach (var error in response.Errors)
{
_logger.LogError(error);
}
return(RedirectToAction(nameof(StartController.Index), "Start"));
}
// bozy: Please provide users with something less technical BUT dump the errors to your log
//It is not technical, it is for example: User name '*****@*****.**' is already taken. It is from Identity.
foreach (var error in result.Errors)
{
ModelState.AddModelError(nameof(RegisterViewModel.Email), error.Description);
_logger.LogError(error.Description);
}
}
vm.TimeZoneList = ToolsExtensions.GetTimeZones();
vm.ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
return(View(nameof(Register), vm));
}
/// <summary>
/// Sends a verification email to the specified user
/// </summary>
/// <param name="displayName">The users display name (typically first name)</param>
/// <param name="email">The users email to be verified</param>
/// <param name="verificationUrl">The URL the user needs to click to verify their email</param>
/// <returns></returns>
public async Task <EmailResponse> SendUserVerificationEmailAsync(string displayName, string email, string verificationUrl)
{
return(await _emailTemplateSender.SendGeneralEmailAsync(new EmailDetails(displayName, email, "Verify Your Email", _applicationConfiguration.CompanyName + " Website Administration", _applicationConfiguration.AdminEmailAddress),
"Verify Email",
$"Hi {displayName ?? "stranger"},",
"Thanks for creating an account with us.<br/>To continue please verify your email with us.",
"Verify Email",
verificationUrl
));
}
public async Task <IActionResult> RegisterAsync(RegisterViewModel vm)
{
if (ModelState.IsValid)
{
var user = new AppUser
{
UserName = vm.Email,
Email = vm.Email,
TimeZone = vm.TimeZone
};
var result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var response = await _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
//ToEmail = user.Email,
ToEmail = "*****@*****.**", // bozy: huh?
Subject = "Welcome to Let's play board game"
}, "Welcome to Let's play board game", "This is content", "This is button", "www.test.pl");
if (!response.Successful)
{
TempData["ErrorMessage"] = Constants.GeneralSendEmailErrorMessage;
foreach (var error in response.Errors)
{
_logger.LogError(error);
}
}
return(RedirectToAction(nameof(StartController.Index), "Start"));
}
else
{
// bozy: Please provide users with something less technical BUT dump the errors to your log
foreach (var error in result.Errors)
{
ModelState.AddModelError(nameof(RegisterViewModel.Email), error.Description);
}
}
}
vm.TimeZoneList = ToolsExtensions.GetTimeZones();
return(View(nameof(Register), vm));
}
public async Task <ResponseError> SendUserEmailVerificationAsync(AppUser user)
{
var userIdentity = await _userManager.FindByNameAsync(user.UserName);
var emailVerificationCode = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var verificationUrl =
$"{_configuration["MVCAppSettings:Url"]}/users/verifyemail?userId={HttpUtility.UrlEncode(userIdentity.Id)}&emailToken={HttpUtility.UrlEncode(emailVerificationCode)}";
return(await _emailSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHtml = true,
FromEmail = _config.Value.SendEmailFromEmail,
FromName = _config.Value.SendEmailFromName,
ToEmail = userIdentity.Email,
ToName = user.UserName,
Subject = "Verify Your Email - Instagram Team"
},
"Verify Email",
$"Hi {user.UserName ?? "stranger"},",
"Thanks for creating an account with us.<br/>To continue please verify your email.",
"Verify Email",
verificationUrl
));
}
public async Task <IActionResult> ChangeStatus(int invitationId, FriendInvitationStatus status)
{
var currentUser = _userManager.FindByNameAsync(User.Identity.Name).Result;
_friendInvitationRepository.ChangeStatus(invitationId, status, currentUser);
var invitation = _friendInvitationRepository.GetInvitation(invitationId);
var appLink = Url.Action(nameof(List), "ReceivedInvitation", null, HttpContext.Request.Scheme);
var response = await _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = invitation.Sender.Email,
Subject = Constants.SubjectNewStatusInvitationEmail
}, status == FriendInvitationStatus.Accepted
?Constants.TitleFriendInvitationAcceptanceEmail
: Constants.TitleFriendInvitationRejectionEmail,
status == FriendInvitationStatus.Accepted
?$"{Constants.ContentFriendInvitationAcceptanceEmail}{invitation.Invited.FullName}"
: $"{Constants.ContentFriendInvitationRejectionEmail}{invitation.Invited.FullName}",
Constants.ButtonCheckFriendInvitation,
appLink);
if (response.Successful)
{
TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
return(RedirectToAction(nameof(List)));
}
foreach (var error in response.Errors)
{
_logger.LogError(error);
}
TempData["ErrorMessage"] = Constants.GeneralSendEmailErrorMessage;
return(RedirectToAction(nameof(List)));
}
public void SendNotification()
{
var usersToSendNotification = _meetingRepository.GetUsersToSendTomorrowsNotification();
foreach (var item in usersToSendNotification)
{
var appLink = Url.Action("Edit", "Meeting", new { id = item.Meeting.MeetingId },
HttpContext.Request.Scheme);
var timeZone = _userManager.FindByIdAsync(item.User.Id).Result.TimeZone;
var StartDateTime = ToolsExtensions
.ConvertToTimeZoneFromUtc(item.Meeting.StartDateTime, timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture);
var content = $"Title: {item.Meeting.Title}, Start date: {StartDateTime}, Organizer: {item.User.FullName}.";
var result = _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = item.User.Email,
Subject = Constants.SubjectTomorrowsMeetingEmail
}, Constants.TitleTomorrowsMeetingEmail,
$"{Constants.ContentTomorrowsMeetingEmail}{content}",
Constants.ButtonCheckMeeting,
appLink);
var notification = _notificationRepository.GetNotification(item.Meeting.MeetingId,
item.User.Id, item.Meeting.StartDateTime) ??
new TomorrowsMeetingsNotification();
notification.Meeting = item.Meeting;
notification.Participant = item.User;
notification.IfSent = result.Result.Successful;
_notificationRepository.SaveNotification(notification);
}
}
public async Task <IActionResult> Delete(string userId, int meetingId)
{
var deletedEntry = _invitedUserRepository.RemoveUserFromMeeting(userId, meetingId);
if (deletedEntry == null)
{
return(RedirectToAction(nameof(List), new { id = meetingId }));
}
var user = _userManager.FindByIdAsync(userId).Result;
var meeting = _meetingRepository.GetMeeting(meetingId);
var appLink = Url.Action("Login", "Account", null, HttpContext.Request.Scheme);
var content =
$"{Constants.ContentDeleteInvitationEmail}: Meeting title: {meeting.Title}, Organizer: {meeting.Organizer.FullName}";
var response = await _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = user.Email,
Subject = Constants.SubjectDeleteInvitationEmail
}, Constants.TitleDeleteInvitationEmail, content,
Constants.ButtonVisitSide,
appLink);
if (response.Successful)
{
TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
return(RedirectToAction(nameof(List), new { id = meetingId }));
}
TempData["ErrorMessage"] = Constants.GeneralSendEmailErrorMessage;
foreach (var error in response.Errors)
{
_logger.LogError(error);
}
return(RedirectToAction(nameof(List), new { id = meetingId }));
}
public IActionResult Create(MessagesListViewModel vm)
{
if (ModelState.IsValid)
{
var message = new Message
{
Text = vm.Text,
Created = DateTime.UtcNow,
AuthorId = GetCurrentUserId().Result,
MeetingId = vm.MeetingId
};
TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
_messageRepository.SaveMessage(message);
}
var appLink = Url.Action(nameof(List), "Message", new { id = vm.MeetingId }, HttpContext.Request.Scheme);
var content = $"{vm.Text}";
var users = _invitedUserRepository.GetUsersEmailsForNotification(vm.MeetingId, GetCurrentUserId().Result);
foreach (var email in users)
{
_templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = email,
Subject = Constants.SubjectNewMessageEmail
}, Constants.TitleNewMessageEmail, $"{Constants.ContentNewMessageEmail}: {content}",
Constants.ButtonCheckMeeting,
appLink)
.ContinueWith(t =>
{
if (t.Result.Successful)
{
return;
}
foreach (var error in t.Result.Errors)
{
_logger.LogError(error);
}
}, TaskScheduler.Default);
}
return(RedirectToAction(nameof(List), new { id = vm.MeetingId }));
}
public Task <SendEmailResponse> SendEmailVerificationMessage(string displayName, string email, string verificationUrl)
{
var message = new Message()
{
From = from,
FromEmail = fromEmail,
To = displayName,
ToEmail = email,
Subject = "Rejestracja konta - SGGW Spaces",
IsHTML = true,
Content = string.Empty
};
return(_templateSender.SendGeneralEmailAsync(message,
"Potwierdź Email",
$"Cześć {displayName},",
"Klikająć w poniższy link dokończysz proces rejestracji. Pozwoli Ci to na dodawanie nowych rezerwacji w naszym serwisie.",
"Potwierdź adres e-mail.",
verificationUrl
));
}
public async Task <IActionResult> Edit(MeetingViewModels.CreateEditMeetingViewModel vm)
{
var startDateUtc = new DateTime();
var endDateUtc = new DateTime();
var currentUserId = GetCurrentUserId().Result;
var timeZone = _userManager
.FindByIdAsync(currentUserId).Result.TimeZone;
if (ModelState.IsValid)
{
if (DateTime.TryParse(vm.StartDateTime, out var startDate) &&
DateTime.TryParse(vm.EndDateTime, out var endDate))
{
startDateUtc = ToolsExtensions.ConvertFromTimeZoneToUtc(startDate, timeZone, _logger);
endDateUtc = ToolsExtensions.ConvertFromTimeZoneToUtc(endDate, timeZone, _logger);
var overlappingMeetings = new List <string>();
overlappingMeetings = vm.MeetingId == 0
? _meetingRepository.GetOverlappingMeetingsForUser(startDateUtc, endDateUtc, currentUserId)
.Select(m => m.Title).ToList()
: _meetingRepository.GetOverlappingMeetingsForMeeting(startDateUtc, endDateUtc, vm.MeetingId)
.Select(m => m.Title).ToList();
if (!ToolsExtensions.IsDateInFuture(startDateUtc))
{
ModelState.AddModelError(nameof(MeetingViewModels.CreateEditMeetingViewModel.StartDateTime),
Constants.FutureDateInPastMessage);
}
if (!ToolsExtensions.IsStartDateBeforeEndDate(startDateUtc, endDateUtc))
{
ModelState.AddModelError(nameof(MeetingViewModels.CreateEditMeetingViewModel.EndDateTime),
Constants.EndDateBeforeStartMessage);
}
if (overlappingMeetings.Count > 0)
{
var overlappingMeetingsTitle = string.Join(", ", overlappingMeetings);
ModelState.AddModelError(nameof(MeetingViewModels.CreateEditMeetingViewModel.Title),
$"{Constants.OverlappingMeetingsMessage}: {overlappingMeetingsTitle}");
}
}
else
{
if (!DateTime.TryParse(vm.StartDateTime, out startDate))
{
ModelState.AddModelError(nameof(MeetingViewModels.CreateEditMeetingViewModel.StartDateTime),
Constants.WrongDateTimeFormat);
}
if (!DateTime.TryParse(vm.EndDateTime, out endDate))
{
ModelState.AddModelError(nameof(MeetingViewModels.CreateEditMeetingViewModel.EndDateTime),
Constants.WrongDateTimeFormat);
}
}
}
if (ModelState.IsValid)
{
var organizer = await _userManager.FindByIdAsync(currentUserId);
var meeting = new Meeting
{
MeetingId = vm.MeetingId,
Title = vm.Title,
StartDateTime = startDateUtc,
EndDateTime = endDateUtc,
Organizer = organizer,
Street = vm.Address.Street,
PostalCode = vm.Address.PostalCode,
City = vm.Address.City,
Country = vm.Address.Country,
Notes = vm.Notes
};
var baseMeeting = _meetingRepository.GetMeeting(meeting.MeetingId);
string changes = null;
if (baseMeeting != null)
{
changes = CompareMeetingData(baseMeeting, meeting, timeZone);
}
_meetingRepository.SaveMeeting(meeting);
var savedGames = GetGameIdsFromMeeting(meeting.MeetingId);
var selectedGames = vm.SelectedGames ?? new List <int>();
var gamesToAdd = selectedGames.Except(savedGames).ToList();
var gamesToRemove = savedGames.Except(selectedGames).ToList();
if (gamesToAdd.Count > 0)
{
foreach (var gameToAdd in gamesToAdd.Select(game => new MeetingGame
{
GameId = game, MeetingId = meeting.MeetingId
}))
{
_meetingRepository.AddGameToMeeting(gameToAdd);
}
}
if (gamesToRemove.Count > 0)
{
foreach (var game in gamesToRemove)
{
_meetingRepository.RemoveGameFromMeeting(game, meeting.MeetingId);
}
}
TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
if (changes == null)
{
return(RedirectToAction(nameof(Edit), new { id = meeting.MeetingId }));
}
var appLink = Url.Action(nameof(Edit), "Meeting", new { id = baseMeeting.MeetingId },
HttpContext.Request.Scheme);
foreach (var email in _invitedUserRepository.GetUsersEmailsForNotification(baseMeeting.MeetingId, currentUserId))
{
_templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = email,
Subject = Constants.SubjectChangeMeetingDataEmail
}, Constants.TitleChangeMeetingDataEmail,
$"{Constants.ContentChangeMeetingDataEmail}: {changes}",
Constants.ButtonCheckMeeting,
appLink)
.ContinueWith(t =>
{
if (t.Result.Successful)
{
return;
}
foreach (var error in t.Result.Errors)
{
_logger.LogError(error);
}
}, TaskScheduler.Default);
}
return(RedirectToAction(nameof(Edit), new { id = meeting.MeetingId }));
}
vm.Games = _meetingRepository.GetGamesForOrganizer(vm.MeetingId, currentUserId).OrderBy(g => g.Title);
return(View(vm));
}
public async Task <IActionResult> SendEmailAsync(EmailFromContactFormModel emailFromForm)
{
// Return bad request if no email sent
if (emailFromForm == null)
{
return(BadRequest());
}
// Add new model error if email and name are the same
if (emailFromForm.Name == emailFromForm.Email)
{
ModelState.AddModelError("FromEmail", "Your name should be different from your email");
}
// Return bad request if the model state failed
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Create new DTO for sending the email
var email = EmailControllerHelper.CreateEmailToSendDto(
emailFromForm.Name,
emailFromForm.Email,
emailFromForm.Message);
// Send the email using the general template and get the response
var response = await _emailTemplateSender.SendGeneralEmailAsync(
email,
$"You've got a message from:<br/>{emailFromForm.Name}",
$"Reply to: {emailFromForm.Email}",
emailFromForm.Message
);
// If the email was not sent...
if (!response.Successful)
{
return(StatusCode(500, "A problem occurred while trying to send the email."));
}
// If the email was sent successfully...
try
{
// Add Html content to email
email.Email.MessageHtml = response.Email.Email.MessageHtml;
// Map email body to email entity
var deliveredEmailEntity = _mapper.Map <EmailMessageModel, DeliveredEmail>(email.Email);
// Populate entity Sender field
PopulateDeliveredEmailAddress(email.Sender,
(senderEmailAddress) => { deliveredEmailEntity.Sender = senderEmailAddress; });
// Populate entity Receiver field
PopulateDeliveredEmailAddress(email.Receiver,
(receiverEmailAddress) => { deliveredEmailEntity.Receiver = receiverEmailAddress; });
// Add new entry into DB
_emailRepository.AddDeliveredEmail(deliveredEmailEntity);
// Save all outstanding changes to DB
if (!_emailRepository.Save())
{
return(StatusCode(500, "A problem occurred while saving to the database."));
}
}
catch (Exception)
{
return(StatusCode(500, "A problem occurred while saving to the database."));
}
// Return email response to client
return(StatusCode(201, response.Successful));
// Helper method that checks if sender/receiver of email already exists in DB - uses those entries if they exist
void PopulateDeliveredEmailAddress(EmailAddressModel person, Action <EmailAddress> setResult)
{
// If current person's email address exists in DB...
if (_emailRepository.EmailAddressExists(person.Email))
{
// Set result to be email address from DB
setResult(_emailRepository.GetEmailAddress(person));
}
// If person is not in DB...
else
{
// Set result to be new email address
setResult(_mapper.Map <EmailAddressModel, EmailAddress>(person));
}
}
}
public async Task <IActionResult> Sent(FriendInvitationViewModel.SentInvitationsViewModel vm)
{
if (string.IsNullOrEmpty(vm.InvitedEmail))
{
TempData["ErrorMessage"] = Constants.EmptyEmailInvitationMessage;
return(RedirectToAction(nameof(List)));
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(List), new { vm.InvitedEmail }));
}
var currentUserId = GetCurrentUserId().Result;
if (_friendInvitationRepository.IfInvitationWasSentByCurrentUser(currentUserId, vm.InvitedEmail))
{
TempData["ErrorMessage"] = Constants.ExistingInvitationSentByCurrentUserErrorMessage;
return(RedirectToAction(nameof(List), new { vm.InvitedEmail }));
}
var invitedUser = _userManager.FindByEmailAsync(vm.InvitedEmail).Result;
var currentUserEmail = _userManager.FindByIdAsync(currentUserId).Result.Email;
if (ToolsExtensions.IfStringsEqual(currentUserEmail, vm.InvitedEmail))
{
TempData["ErrorMessage"] = Constants.InvitationSentToAndByCurrentUserErrorMessage;
return(RedirectToAction(nameof(List), new { vm.InvitedEmail }));
}
if (invitedUser != null &&
_friendInvitationRepository.IfInvitationWasReceivedByCurrentUser(invitedUser.Id, currentUserEmail))
{
TempData["ErrorMessage"] = Constants.ExistingInvitationReceivedByCurrentUserErrorMessage;
return(RedirectToAction(nameof(List), new { vm.InvitedEmail }));
}
var appLinkRegister = Url.Action("Register", "Account", new { Email = vm.InvitedEmail },
HttpContext.Request.Scheme);
var appLinkInvitations = Url.Action("List", "ReceivedInvitation", null, HttpContext.Request.Scheme);
var response = await _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = vm.InvitedEmail,
Subject = Constants.SubjectNewFriendInvitationEmail
}, Constants.TitleNewFriendInvitationEmail,
invitedUser != null
?Constants.ContentNewFriendInvitationExistingUserEmail
: Constants.ContentNewFriendInvitationNonExistingUserEmail,
invitedUser != null?Constants.ButtonCheckFriendInvitation : Constants.ButtonVisitSide,
invitedUser != null?appLinkInvitations : appLinkRegister);
if (response.Successful)
{
var invitation = new FriendInvitation();
if (invitedUser != null)
{
invitation.Invited = invitedUser;
TempData["SuccessMessage"] = Constants.ExistingAccountSentInvitationMessage;
}
else
{
TempData["SuccessMessage"] = Constants.NoAccountSentInvitationMessage;
}
invitation.InvitedEmail = vm.InvitedEmail;
invitation.SenderId = currentUserId;
_friendInvitationRepository.AddInvitation(invitation);
return(RedirectToAction(nameof(List)));
}
_logger.LogCritical(vm.InvitedEmail);
TempData["ErrorMessage"] =
$"{Constants.GeneralSendEmailErrorMessage} {Constants.FriendInvitationEmailErrorMessage}";
foreach (var error in response.Errors)
{
_logger.LogError(error);
}
return(RedirectToAction(nameof(List), new { vm.InvitedEmail }));
}
