public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? this.Url.Content("~/");
this.ExternalLogins = (await this.signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (this.ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = this.Input.Username,
Email = this.Input.Email
};
var result = await this.userManager.CreateAsync(user, this.Input.Password);
if (result.Succeeded)
{
this.logger.LogInformation("User created a new account with password.");
if (this.Input.IsArenaAdministrator == true)
{
await this.userManager.AddToRoleAsync(user, GlobalConstants.ArenaAdminRoleName);
this.logger.LogInformation("User registered as Arena Administrator.");
}
var code = await this.userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = this.Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: this.Request.Scheme);
await this.emailSender.SendEmailAsync(
this.Input.Email,
EmailSubjectConstants.RegisterConfirmationSubject,
EmailHtmlMessages.GetEmailConfirmationHtml(this.Input.Username, HtmlEncoder.Default.Encode(callbackUrl)));
if (this.userManager.Options.SignIn.RequireConfirmedAccount)
{
return(this.RedirectToPage("RegisterConfirmation", new { email = this.Input.Email }));
}
else
{
await this.signInManager.SignInAsync(user, isPersistent : false);
return(this.LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(this.Page());
}
public async Task UpdateAsync(UserUpdateInputModel inputModel, string userId, string userEmail, string username)
{
var user = await this.GetUserByIdAsIQueryable(userId).FirstAsync();
user.FirstName = inputModel.FirstName;
user.LastName = inputModel.LastName;
user.Gender = inputModel.Gender;
user.SportId = inputModel.SportId;
user.Status = inputModel.Status;
user.CountryId = inputModel.CountryId;
user.CityId = inputModel.CityId;
user.PhoneNumber = inputModel.PhoneNumber;
user.FaceBookAccount = inputModel.FaceBookAccount;
user.Age = inputModel.Age;
user.Occupation = inputModel.Occupation;
user.IsUserProfileUpdated = true;
if (inputModel.AvatarImage != null)
{
var avatar = await this.imagesService.CreateAsync(inputModel.AvatarImage);
user.AvatarId = avatar.Id;
}
this.usersRepository.Update(user);
await this.usersRepository.SaveChangesAsync();
await this.emailSender.SendEmailAsync(
userEmail,
EmailSubjectConstants.ProfileUpdated,
EmailHtmlMessages.GetUpdateProfileHtml(username));
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { area = "Identity", code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(
Input.Email,
EmailSubjectConstants.ResetPasswordSubject,
EmailHtmlMessages.GetResetPasswordHtml(user.UserName, HtmlEncoder.Default.Encode(callbackUrl)));
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
public async Task ChangeStatus(int eventId, ArenaRequestStatus status)
{
var evt = await this.GetAsIQuerableById(eventId).FirstOrDefaultAsync();
if (evt != null)
{
evt.RequestStatus = status;
this.eventsRepository.Update(evt);
await this.eventsRepository.SaveChangesAsync();
var sportName = await this.sportsService.GetNameByIdAsync(evt.SportId);
var users = await this.eventsUsersRepository
.All()
.Where(eu => eu.EventId == eventId)
.Select(eu => new EmailUserInfo {
Email = eu.User.Email, Username = eu.User.UserName,
})
.ToListAsync();
foreach (var player in users)
{
await this.emailSender.SendEmailAsync(
player.Email,
EmailSubjectConstants.StatusChanged,
EmailHtmlMessages.GetStatusChangedHtml(
player.Username, sportName, evt.Name, evt.Date, status.GetDisplayName()));
}
}
}
public async Task ReplyAsync(int id, string replyContent, string recipientEmail)
{
await this.emailSender.SendEmailAsync(
recipientEmail,
EmailSubjectConstants.ContactFormReply,
EmailHtmlMessages.GetContactFormReplyHtml(replyContent));
await this.SetReplyedAsync(id, replyContent);
}
private async Task ChangeEventStatusAsync(int eventId)
{
var evt = await this.GetAsIQuerableById(eventId).FirstOrDefaultAsync();
if (evt != null)
{
var currentStatus = evt.Status;
if (evt.MaxPlayers == evt.Users.Count)
{
evt.Status = EventStatus.Full;
}
else if (evt.MinPlayers > evt.Users.Count)
{
evt.Status = EventStatus.AcceptingPlayers;
}
else if (evt.MaxPlayers > evt.Users.Count)
{
evt.Status = EventStatus.MinimumPlayersReached;
}
if (currentStatus != evt.Status)
{
this.eventsRepository.Update(evt);
await this.eventsRepository.SaveChangesAsync();
var sportName = await this.sportsService.GetNameByIdAsync(evt.SportId);
var users = await this.eventsUsersRepository
.All()
.Where(eu => eu.EventId == eventId)
.Select(eu => new EmailUserInfo {
Email = eu.User.Email, Username = eu.User.UserName,
})
.ToListAsync();
foreach (var user in users)
{
await this.emailSender.SendEmailAsync(
user.Email,
EmailSubjectConstants.ChangedStatus,
EmailHtmlMessages.GetChangedStatusHtml(
user.Username, sportName, evt.Name, evt.Date, currentStatus.GetDisplayName()));
}
}
}
}
public async Task CancelEventAsync(int eventId, string userEmail, string username)
{
var evt = await this.GetAsIQuerableById(eventId).FirstOrDefaultAsync();
if (evt != null)
{
evt.Status = EventStatus.Canceled;
this.eventsRepository.Update(evt);
await this.eventsRepository.SaveChangesAsync();
var eventUsers = await this.eventsUsersRepository
.All()
.Where(eu => eu.EventId == eventId)
.ToListAsync();
for (int i = 0; i < eventUsers.Count; i++)
{
this.eventsUsersRepository.Delete(eventUsers[i]);
}
await this.eventsUsersRepository.SaveChangesAsync();
var sportName = await this.sportsService.GetNameByIdAsync(evt.SportId);
await this.emailSender.SendEmailAsync(
userEmail,
EmailSubjectConstants.CancelEvent,
EmailHtmlMessages.GetCancelEventHtml(username, sportName, evt.Name, evt.Date));
var users = await this.eventsUsersRepository
.All()
.Where(eu => eu.EventId == eventId)
.Select(eu => new EmailUserInfo {
Email = eu.User.Email, Username = eu.User.UserName
})
.ToListAsync();
foreach (var user in users)
{
await this.emailSender.SendEmailAsync(
user.Email,
EmailSubjectConstants.EventCanceled,
EmailHtmlMessages.GetEventCanceledHtml(user.Username, evt.Admin.UserName, sportName, evt.Name, evt.Date));
}
}
}
public async Task RemoveUserAsync(int eventId, string userId, string username, string email)
{
var eventUser = await this.eventsUsersRepository
.All()
.Where(eu => eu.EventId == eventId && eu.UserId == userId)
.FirstOrDefaultAsync();
if (eventUser == null)
{
throw new ArgumentException(string.Format(EventIvanlidIdwithUserIdErrorMessage, userId, eventId));
}
this.eventsUsersRepository.Delete(eventUser);
await this.eventsUsersRepository.SaveChangesAsync();
await this.messagesService.CreateAsync(EventLeavingMessage, userId, eventId);
await this.ChangeEventStatusAsync(eventId);
var eventObject = await this.GetEventDetailsForEmailByIdAsync(eventId);
await this.emailSender.SendEmailAsync(
email,
EmailSubjectConstants.LeftEvent,
EmailHtmlMessages.GetLeaveEventHtml(username, eventObject));
var users = await this.eventsUsersRepository
.All()
.Where(eu => eu.EventId == eventId)
.Select(eu => new EmailUserInfo {
Email = eu.User.Email, Username = eu.User.UserName,
})
.ToListAsync();
foreach (var player in users)
{
await this.emailSender.SendEmailAsync(
player.Email,
EmailSubjectConstants.UserLeft,
EmailHtmlMessages.GetUserLeftHtml(
player.Username, eventObject.Sport, eventObject.Name, eventObject.Date, username));
}
}
public async Task <int> FileContactFormAsync(ContactIndexViewModel inputModel)
{
var contactFormEntry = new ContactForm
{
Email = inputModel.Email,
Content = inputModel.Content,
Name = inputModel.Name,
Title = inputModel.Title,
};
await this.contactFormsRepository.AddAsync(contactFormEntry);
await this.contactFormsRepository.SaveChangesAsync();
await this.emailSender.SendEmailAsync(
inputModel.Email,
inputModel.Name,
EmailHtmlMessages.GetContactFormContentHtml(inputModel.Name, inputModel.Title, inputModel.Content));
return(contactFormEntry.Id);
}
public async Task <int> CreateAsync(
EventCreateInputModel inputModel, int cityId, int countryId, string userId, string userEmail, string username)
{
var @event = inputModel.To <Event>();
@event.CityId = cityId;
@event.CountryId = countryId;
@event.AdminId = userId;
await this.eventsRepository.AddAsync(@event);
await this.eventsRepository.SaveChangesAsync();
await this.eventsUsersRepository.AddAsync(new EventUser
{
EventId = @event.Id,
UserId = userId,
});
await this.eventsUsersRepository.SaveChangesAsync();
var eventId = @event.Id;
await this.messagesService.CreateAsync(EventCreationMessage, userId, eventId);
var sportName = await this.sportsService.GetNameByIdAsync(inputModel.SportId);
await this.emailSender.SendEmailAsync(
userEmail,
EmailSubjectConstants.EventCreated,
EmailHtmlMessages.GetEventCreationHtml(
username,
inputModel.Name,
sportName,
inputModel.Date.ToString(DefaultDateFormat),
inputModel.StartingHour.ToString(DefaultTimeFormat)));
return(eventId);
}
public async Task AddUserAsync(int eventId, string userId, string userEmail, string username)
{
var eventUser = new EventUser
{
EventId = eventId,
UserId = userId,
};
await this.eventsUsersRepository.AddAsync(eventUser);
await this.eventsUsersRepository.SaveChangesAsync();
await this.messagesService.CreateAsync(EventJoiningMessage, userId, eventId);
await this.ChangeEventStatusAsync(eventId);
var eventObject = await this.GetEventDetailsForEmailByIdAsync(eventId);
await this.emailSender.SendEmailAsync(
userEmail,
EmailSubjectConstants.JoinedEvent,
EmailHtmlMessages.GetJoinEventHtml(username, eventObject));
}
public async Task CreateAsync(ArenaCreateInputModel inputModel, string userId, string userEmail, string username)
{
var arena = inputModel.To <Arena>();
arena.ArenaAdminId = userId;
if (inputModel.MainImageFile != null)
{
var avatar = await this.imagesService.CreateAsync(inputModel.MainImageFile);
arena.MainImageId = avatar.Id;
}
if (inputModel.ImageFiles != null)
{
foreach (var img in inputModel.ImageFiles)
{
var image = await this.imagesService.CreateAsync(img);
arena.Images.Add(image);
}
}
await this.arenasRepository.AddAsync(arena);
await this.arenasRepository.SaveChangesAsync();
var sportName = await this.sportsService.GetNameByIdAsync(inputModel.SportId);
await this.emailSender.SendEmailAsync(
userEmail,
EmailSubjectConstants.ArenaCreated,
EmailHtmlMessages.GetArenaCreationHtml(
username,
inputModel.Name,
sportName));
}
public async Task <int> InviteUsersToEventAsync(int id, string userName)
{
var query = this.GetAsIQuerableById(id);
if (query.Any())
{
var serviceModel = await query
.Select(e => new InviteUsersMessagingModel
{
ArenaName = e.Arena.Name,
EventName = e.Name,
Sport = e.Sport.Name,
SportId = e.Sport.Id,
Date = e.Date,
StartingTime = e.StartingHour,
Username = userName,
ArenaCityId = e.Arena.CityId,
})
.FirstOrDefaultAsync();
var eventLink = $"LetsSport.com/Events/Details/{id}";
var userEmails = await this.usersService.GetAllUsersDetailsForIvitationAsync(
serviceModel.SportId, serviceModel.ArenaCityId);
foreach (var user in userEmails)
{
await this.emailSender.SendEmailAsync(
user.Email,
EmailSubjectConstants.UserInvitation,
EmailHtmlMessages.GetUserInvitationHtml(serviceModel, user.Username, eventLink));
}
return(userEmails.Count());
}
return(0);
}
