public async Task <IActionResult> UserProfileAsync(UserProfileViewModel vm)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
if (user != null)
{
user.FirstName = vm.FirstName;
user.LastName = vm.LastName;
user.Street = vm.Address.Street;
user.City = vm.Address.City;
user.Country = vm.Address.Country;
user.PostalCode = vm.Address.PostalCode;
user.PhoneNumber = vm.PhoneNumber;
user.TimeZone = vm.TimeZone;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
return(RedirectToAction(nameof(UserProfileAsync)));
}
}
_logger.LogCritical(Constants.UnknownId + " of user");
return(RedirectToAction(nameof(ErrorController.Error), "Error"));
}
vm.TimeZoneList = ToolsExtensions.GetTimeZones();
return(View("UserProfile", vm));
}
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);
}
}
private string CompareMeetingData(Meeting oldMeeting, Meeting newMeeting, string timeZone)
{
string changes = null;
var oldStartDateUtc = DateTime.SpecifyKind(oldMeeting.StartDateTime, DateTimeKind.Utc);
var newStartDateUtc = DateTime.SpecifyKind(newMeeting.StartDateTime, DateTimeKind.Utc);
if (oldMeeting.StartDateTime != newMeeting.StartDateTime)
{
changes += string.Join(", ",
$"{Constants.OldValueMeetingMessage} Start date: {ToolsExtensions.ConvertToTimeZoneFromUtc(oldStartDateUtc, timeZone, _logger).ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture)}, " +
$"{Constants.CurrentValueMeetingMessage} Start date: {ToolsExtensions.ConvertToTimeZoneFromUtc(newStartDateUtc, timeZone, _logger).ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture)}, ");
}
if (!ToolsExtensions.IfStringsEqual(oldMeeting.Street, newMeeting.Street))
{
changes += string.Join(", ",
$"{Constants.OldValueMeetingMessage} Street (address): {oldMeeting.Street}, " +
$"{Constants.CurrentValueMeetingMessage} Street (address): {newMeeting.Street}, ");
}
if (!ToolsExtensions.IfStringsEqual(oldMeeting.City, newMeeting.City))
{
changes += string.Join(", ",
$"{Constants.OldValueMeetingMessage} City (address): {oldMeeting.City}, " +
$"{Constants.CurrentValueMeetingMessage} City (address): {newMeeting.City}");
}
return(changes);
}
public IActionResult List()
{
//TODO sort by status, PEnding first, then sort by Date
var currentUser = _userManager.FindByNameAsync(User.Identity.Name).Result;
var timeZone = currentUser.TimeZone;
var receivedInvitationsList = _friendInvitationRepository
.GetInvitationsReceivedByCurrentUser(currentUser.Email)
.Select(item => new FriendInvitationViewModel.ReceivedInvitationsList
{
SenderUserName = item.Sender.FullName,
SenderEmail = item.Sender.Email,
Status = item.Status,
PostDate = ToolsExtensions.ConvertToTimeZoneFromUtc(item.PostDateTime, timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture),
InvitationId = item.FriendInvitationId
})
.ToList();
var vm = new FriendInvitationViewModel.ReceivedInvitationsViewModel
{
ReceivedInvitationsList = receivedInvitationsList
};
return(View(vm));
}
private TimeZoneInfo GetTimeZoneOfCurrentUser()
{
var currentUser = _userManager.FindByNameAsync(User.Identity.Name).Result;
var currentUserTimeZone = currentUser.TimeZone;
return(ToolsExtensions.ConvertTimeZone(currentUserTimeZone, _logger));
}
public async Task <IActionResult> UserProfileAsync()
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
_logger.LogCritical(Constants.UnknownId + " of user");
return(RedirectToAction(nameof(ErrorController.Error), "Error"));
}
var vm = new UserProfileViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
TimeZoneList = ToolsExtensions.GetTimeZones(),
TimeZone = user.TimeZone,
Address = new AddressViewModels
{
Street = user.Street,
City = user.City,
Country = user.Country,
PostalCode = user.PostalCode
}
};
return(View("UserProfile", vm));
}
public ViewResult Index()
{
var currentUserId = GetCurrentUserId().Result;
var timeZone = _userManager
.FindByIdAsync(currentUserId).Result.TimeZone;
var upcomingMeetings = _meetingRepository.GetMeetingsForUserForNextDays(currentUserId, 7)
.OrderBy(m => m.StartDateTime);
var list = (from meeting in upcomingMeetings
let games = string.Join(", ", meeting.MeetingGame.Select(mg => mg.Game.Title))
let people = string.Join(", ", meeting.MeetingInvitedUser.Select(iu => iu.AppUser.FullName))
.Insert(0, $"{meeting.Organizer.FullName}, ")
let startDateUtc = ToolsExtensions.ConvertToTimeZoneFromUtc(meeting.StartDateTime, timeZone, _logger)
select new UpcomingMeetings()
{
StartDate = startDateUtc.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture),
Games = games, People = people,
Url = Url.Action("Edit", "Meeting", new { id = meeting.MeetingId.ToString() },
HttpContext.Request.Scheme)
}).ToList();
var mv = new StartViewModels {
UpcomingMeetings = list
};
return(View(mv));
}
public ViewResult HangingTree()
{
var game = _gameRepository.Games.Any() ?
ToolsExtensions.Random(_gameRepository.Games) : new Game {
Title = "Empty base", GameId = 42
};
return(View(game));
}
public IEnumerable <Meeting> Get()
{
var currentUserId = GetCurrentUserId().Result;
var currentUser = _userManager.FindByIdAsync(currentUserId).Result;
var currentUserTimeZone = currentUser.TimeZone;
var timeZone = ToolsExtensions.ConvertTimeZone(currentUserTimeZone, _logger);
var meetings = _meetingRepository.GetMeetingsForUser(currentUserId);
return(GetMeetingsWithDates(meetings, timeZone));
}
public void Account_info_return_listof_playerInfo()
{
var createdAtDate = ToolsExtensions.DateFromWGTimestamp(createdAt);
var result = WGApplication.GetPlayerInfo(new[] { accountId });
Assert.IsNotNull(result.Data);
Assert.AreEqual("ok", result.Status);
Assert.AreEqual(result.Data[0].AccountId, accountId);
Assert.AreEqual(result.Data[0].CreatedAt, createdAtDate.DateToWGTimesptamp());
}
public void Account_info_return_listof_playerInfo_using_all_parameters_except_accessToken()
{
var createdAtDate = ToolsExtensions.DateFromWGTimestamp(createdAt);
var result = WGApplication.GetPlayerInfo(new[] { accountId }, WGLanguageField.EN, null, "account_id,created_at");
Assert.IsNotNull(result.Data);
Assert.AreEqual("ok", result.Status);
Assert.AreEqual(result.Data[0].AccountId, accountId);
Assert.AreEqual(result.Data[0].CreatedAt, createdAtDate.DateToWGTimesptamp());
}
public IActionResult Register()
{
if (!User?.Identity?.IsAuthenticated ?? false)
{
return(View(new RegisterViewModel {
TimeZoneList = ToolsExtensions.GetTimeZones()
}));
}
return(RedirectToAction(nameof(ShelfController.List), "Shelf"));
}
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));
}
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 IEnumerable <Meeting> Get()
{
var currentUserId = GetCurrentUserId().Result;
var currentUser = _userManager.FindByIdAsync(currentUserId).Result;
var timeZone = currentUser.TimeZone;
var list = _meetingRepository.GetMeetingsForUser(currentUserId).ToList();
foreach (var meeting in list)
{
meeting.StartDateTime =
ToolsExtensions.ConvertToTimeZoneFromUtc(meeting.StartDateTime, timeZone, _logger);
meeting.EndDateTime = ToolsExtensions.ConvertToTimeZoneFromUtc(meeting.EndDateTime, timeZone, _logger);
}
return(list.AsEnumerable());
}
public async Task <IActionResult> Register(string returnUrl, string email)
{
var model = new RegisterViewModel
{
Email = email,
ReturnUrl = returnUrl,
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList(),
TimeZoneList = ToolsExtensions.GetTimeZones()
};
if (!User?.Identity?.IsAuthenticated ?? false)
{
return(View(model));
}
return(RedirectToAction(nameof(ShelfController.List), "Shelf"));
}
public IActionResult Create()
{
var currentUser = _userManager.FindByNameAsync(User.Identity.Name).Result;
var timeZone = currentUser.TimeZone;
return(View(nameof(Edit), new MeetingViewModels.CreateEditMeetingViewModel
{
Organizer = currentUser.FullName,
Games = _meetingRepository.GetGamesForOrganizer(0, currentUser.Id),
StartDateTime = ToolsExtensions.ConvertToTimeZoneFromUtc(DateTime.UtcNow.AddHours(1), timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture),
EndDateTime = ToolsExtensions.ConvertToTimeZoneFromUtc(DateTime.UtcNow.AddHours(2), timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture),
IsEditable = true,
Address = new AddressViewModels(),
TimeZone = timeZone
}));
}
public IActionResult List(FriendInvitationViewModel.SentInvitationsViewModel vm)
{
var currentUser = _userManager.FindByNameAsync(User.Identity.Name).Result;
var timeZone = currentUser.TimeZone;
var sentInvitationsList = _friendInvitationRepository
.GetInvitationsSentByCurrentUser(currentUser.Id)
.Select(item => new FriendInvitationViewModel.SentInvitationsList()
{
InvitedUser = item.Invited != null
? item.Invited.FullName
: item.InvitedEmail,
InvitedEmail = item.InvitedEmail,
Status = item.Status,
PostDate = ToolsExtensions.ConvertToTimeZoneFromUtc(item.PostDateTime, timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture)
})
.ToList();
vm.InvitedUsersList = sentInvitationsList;
return(View(vm));
}
public IActionResult Edit(int id)
{
var currentUserId = GetCurrentUserId().Result;
var meeting = _meetingRepository.GetMeeting(id);
if (meeting == null)
{
_logger.LogCritical($"{Constants.UnknownId} of meeting");
return(RedirectToAction(nameof(ErrorController.Error), "Error"));
}
var timeZone = _userManager.FindByIdAsync(currentUserId).Result.TimeZone;
var vm = new MeetingViewModels.CreateEditMeetingViewModel
{
Organizer = meeting.Organizer.FullName,
Title = meeting.Title,
MeetingId = meeting.MeetingId,
StartDateTime = ToolsExtensions.ConvertToTimeZoneFromUtc(meeting.StartDateTime, timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture),
EndDateTime = ToolsExtensions.ConvertToTimeZoneFromUtc(meeting.EndDateTime, timeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture),
Notes = meeting.Notes,
Games = _meetingRepository.GetGamesForOrganizer(id, meeting.OrganizerId).OrderBy(g => g.Title),
SelectedGames = GetGameIdsFromMeeting(id),
IsEditable = meeting.Organizer.UserName == User.Identity.Name,
TimeZone = timeZone,
Address = new AddressViewModels
{
Street = meeting.Street,
City = meeting.City,
PostalCode = meeting.PostalCode,
Country = meeting.Country
}
};
return(View(vm));
}
public IActionResult List(int id)
{
if (id == 0)
{
return(RedirectToAction(nameof(MeetingController.List), "Meeting"));
}
var currentUserId = GetCurrentUserId().Result;
var currentUser = _userManager.FindByIdAsync(currentUserId).Result;
var timeZone = currentUser.TimeZone;
var messages = _messageRepository.GetMessagesForMeeting(id).ToList();
foreach (var message in messages)
{
message.Created = ToolsExtensions.ConvertToTimeZoneFromUtc(message.Created, timeZone, _logger);
message.Author.Email = message.Author.Email.Trim().ToLower();
}
return(View(new MessagesListViewModel {
Messages = messages, MeetingId = id
}));
}
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> ExternalLoginCallback(string timeZone, AuthPageType pageType = AuthPageType.Login,
string returnUrl = null, string remoteError = null)
{
var view = new ViewResult();
var field = string.Empty;
switch (pageType)
{
case AuthPageType.Login:
returnUrl = returnUrl ?? Url.Content("~/");
view = View("Login", new LoginViewModel
{
ReturnUrl = returnUrl,
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
});
field = nameof(LoginViewModel.Email);
break;
case AuthPageType.Register:
returnUrl = Url.Action(nameof(StartController.Index), "Start");
field = nameof(RegisterViewModel.Email);
view = View("Register", new RegisterViewModel()
{
ReturnUrl = returnUrl,
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList(),
TimeZoneList = ToolsExtensions.GetTimeZones()
});
break;
}
if (remoteError != null)
{
ModelState.AddModelError(field, Constants.AuthProviderError);
_logger.LogError($"{Constants.AuthProviderKnownError}: {remoteError}");
return(view);
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ModelState.AddModelError(field, Constants.AuthProviderError);
_logger.LogError(Constants.AuthProviderUnknownError);
return(view);
}
var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider,
info.ProviderKey, false, true);
if (result.Succeeded)
{
return(LocalRedirect(returnUrl));
}
var email = info.Principal.FindFirstValue(ClaimTypes.Email);
if (email == null)
{
ModelState.AddModelError(field, Constants.AuthProviderError);
_logger.LogError(Constants.AuthProviderUnknownEmailError);
return(view);
}
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
user = new AppUser
{
UserName = info.Principal.FindFirstValue(ClaimTypes.Email),
Email = info.Principal.FindFirstValue(ClaimTypes.Email),
TimeZone = timeZone ?? ToolsExtensions.GetTimeZones().FirstOrDefault().Key
};
var resultCreate = await _userManager.CreateAsync(user);
if (resultCreate.Succeeded)
{
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)
{
TempData["ErrorMessage"] = Constants.GeneralSendEmailErrorMessage;
foreach (var error in response.Errors)
{
_logger.LogError(error);
}
}
}
}
await _userManager.AddLoginAsync(user, info);
await _signInManager.SignInAsync(user, false);
return(LocalRedirect(returnUrl));
}
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 }));
}
public async Task <IActionResult> Edit(MeetingViewModels.CreateEditMeetingViewModel vm)
{
var timeZone = GetTimeZoneOfCurrentUser();
var startDateUTC = TimeZoneInfo.ConvertTimeToUtc(vm.StartDateTime, timeZone);
var endDateUTC = TimeZoneInfo.ConvertTimeToUtc(vm.EndDateTime, timeZone);
var currentUserId = GetCurrentUserId().Result;
var overlappingMeetings = new List <Meeting>();
overlappingMeetings = vm.MeetingId == 0
? _meetingRepository.GetOverlappingMeetingsForUser(startDateUTC, endDateUTC, currentUserId).ToList()
: _meetingRepository.GetOverlappingMeetingsForMeeting(startDateUTC, endDateUTC, vm.MeetingId).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 = ": ";
foreach (var meeting in overlappingMeetings)
{
overlappingMeetingsTitle += meeting.Title + " ";
}
ModelState.AddModelError(nameof(MeetingViewModels.CreateEditMeetingViewModel.OrganizerId),
Constants.OverlappingMeetingsMessage + overlappingMeetingsTitle);
}
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
};
_meetingRepository.SaveMeeting(meeting);
var savedGames = GetGameIdsFromMeeting(meeting.MeetingId);
var selectedGames = vm.SelectedGames ?? new int[0];
var gamesToAdd = selectedGames.Except(savedGames).ToList();
var gamesToRemove = savedGames.Except(selectedGames).ToList();
if (gamesToAdd.Count > 0)
{
foreach (var game in gamesToAdd)
{
var gameToAdd = 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;
return(RedirectToAction(nameof(Edit), new { id = meeting.MeetingId }));
}
vm.Organizers = _userManager.Users.ToList();
vm.Games = _gameRepository.Games.ToList();
return(View(vm));
}
public async Task <IActionResult> Add(InvitedUserViewModel.InvitedUserListViewModel vm)
{
var userId = vm.SelectedToInviteUserId;
var meetingId = vm.MeetingId;
if (_invitedUserRepository.IfUserIsInvited(meetingId, userId))
{
TempData["ErrorMessage"] = Constants.ExistingMeetingInvitationMessage;
return(RedirectToAction(nameof(List), new { id = meetingId }));
}
var meeting = _meetingRepository.GetMeeting(meetingId);
var user = _userManager.FindByIdAsync(userId).Result;
var games = meeting.MeetingGame.Select(mg => mg.Game.Title);
var meetingStartDate = ToolsExtensions
.ConvertToTimeZoneFromUtc(meeting.StartDateTime, user.TimeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture);
var meetingEndDate = ToolsExtensions.ConvertToTimeZoneFromUtc(meeting.EndDateTime, user.TimeZone, _logger)
.ToString(Constants.DateTimeFormat, CultureInfo.InvariantCulture);
var overlappingMeetings = new List <string>();
overlappingMeetings = _meetingRepository
.GetOverlappingMeetingsForUser(meeting.StartDateTime, meeting.EndDateTime, userId)
.Select(m => m.Title)
.ToList();
// bozy This variable should be inside the if part. Moreover setting a variable with a single space is a code smell
if (overlappingMeetings.Count > 0)
{
// use string.Join() instead of foreach.
var overlappingMeetingsTitle = string.Join(", ", overlappingMeetings);
TempData["ErrorMessage"] = $"{Constants.OverlappingMeetingsMessage}: {overlappingMeetingsTitle}";
return(RedirectToAction(nameof(List), new { id = meetingId }));
}
_invitedUserRepository.AddUserToMeeting(userId, meetingId, InvitationStatus.Pending);
TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
var appLink = Url.Action(nameof(List), "InvitedUser", new { id = meetingId }, HttpContext.Request.Scheme);
var content =
$"{Constants.ContentInviteUserEmail}: Organizer: {meeting.Organizer.FullName}; Start date: {meetingStartDate}; End date: {meetingEndDate};" +
$" Games: {string.Join(", ", games)}";
var response = await _templateSender.SendGeneralEmailAsync(new SendEmailDetails
{
IsHTML = true,
ToEmail = user.Email,
Subject = Constants.SubjectInviteUserEmail
}, Constants.TitleInviteUserEmail, content,
Constants.ButtonCheckMeeting,
appLink);
if (response.Successful)
{
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 }));
}
