public async Task <IActionResult> AddOffer(int schoolId, OfferForCreateDto offerForCreateDto)
{
var school = await database.SchoolRepository.Get <School>(schoolId);
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (currentUserId != school.OwnerId)
{
return(this.Forbidden("Nie jesteś właścicielem tej szkółki"));
}
var offer = mapper.Map <Offer>(offerForCreateDto);
var package = mapper.Map <Package>(offerForCreateDto.PackageForCreateDto);
if (await schoolService.AddOffer(offer, school, package))
{
var offerToReturn = mapper.Map <OfferDetailsDto>(offer);
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.OfferCreated(school.Name, offer.Name), school);
return(Ok(offerToReturn));
}
return(BadRequest("Nie udało się dodać oferty"));
}
public async Task <IActionResult> UpdateTrip(int schoolId, int tripId, TripForUpdateDto tripForUpdateDto)
{
var school = await database.SchoolRepository.Get <School>(schoolId);
var trip = school.Trips.FirstOrDefault(t => t.Id == tripId);
if (trip == null)
{
throw new EntityNotFoundException("Wycieczka");
}
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (currentUserId != school.OwnerId)
{
return(this.Forbidden("Nie jesteś właścicielem tej szkółki"));
}
trip = mapper.Map <TripForUpdateDto, Trip>(tripForUpdateDto, trip);
if (await database.Complete())
{
await notificationSystem.PushNotificationToUsersByTripFollows(StaticExpressions.TripUpdated(school.Name, trip.Name), trip);
return(NoContent());
}
return(BadRequest("Nie udało się zaktualizować wycieczki"));
}
public async Task <IActionResult> UpdateOffer(int schoolId, int offerId, OfferForUpdateDto offerForUpdateDto)
{
var school = await database.SchoolRepository.Get <School>(schoolId);
var offer = school.Offers.FirstOrDefault(o => o.Id == offerId);
if (offer == null)
{
throw new EntityNotFoundException("Oferta");
}
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (currentUserId != school.OwnerId)
{
return(this.Forbidden("Nie jesteś właścicielem tej szkółki"));
}
offer = mapper.Map <OfferForUpdateDto, Offer>(offerForUpdateDto, offer);
if (await database.Complete())
{
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.OfferUpdated(school.Name, offer.Name), school);
return(NoContent());
}
return(BadRequest("Nie udało się zaktualizować ofery"));
}
public async Task <IActionResult> SetLogo(int schoolId, [FromForm] IFormFile logo)
{
if (logo != null &&
!filesUploader.IsValidExtension(logo.FileName, PhotoExtensions))
{
return(BadRequest("Logo posiada niepoprawny format"));
}
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var school = await database.SchoolRepository.Get <School>(schoolId);
if (currentUserId != school.OwnerId && !await rolesService.IsPermitted(RolesPermitted, currentUserId))
{
return(this.Forbidden("Nie jesteś właścicielem tej szkółki"));
}
if (await SetLogoUrl(logo, school))
{
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.SchoolUpdated(school.Name), school);
return(NoContent());
}
return(BadRequest("Logo nie zostało zaktualizowane"));
}
public async Task <IActionResult> AddOpinion(int schoolId, OpinionForCreateDto opinionForCreateDto)
{
var school = await database.SchoolRepository.Get <School>(schoolId);
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (schoolService.UserOpinionExists(currentUserId, school))
{
return(BadRequest("Dla wybranej szkółki możesz dodać tylko jedną opinię"));
}
if (currentUserId == school.OwnerId)
{
return(this.Forbidden("Nie możesz dodać opinii dla swojej szkółki"));
}
var opinion = mapper.Map <Opinion>(opinionForCreateDto);
if (await schoolService.AddOpinion(opinion, school, currentUserId))
{
var opinionToReturn = mapper.Map <OpinionDetailsDto>(opinion);
await notificationSystem.PushNotification(school.OwnerId, StaticExpressions.OpinionCreatedForOwner(opinion.User.UserName), NotificationType.School);
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.OpinionCreated(opinion.User.UserName, school.Name), school);
return(Ok(opinionToReturn));
}
return(BadRequest("Nie udało się dodać opinii"));
}
public async Task <IActionResult> UpdateOpinion(int schoolId, int opinionId, OpinionForUpdateDto opinionForUpdateDto)
{
var school = await database.SchoolRepository.Get <School>(schoolId);
var opinion = school.Opinions.FirstOrDefault(o => o.Id == opinionId);
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (opinion == null)
{
throw new EntityNotFoundException("Opinia");
}
if (currentUserId != opinion.UserId)
{
return(this.Forbidden("Nie możesz aktualizować nie swojej opinii"));
}
opinion = mapper.Map <OpinionForUpdateDto, Opinion>(opinionForUpdateDto, opinion);
if (await schoolService.UpdateOpinion(school, opinion))
{
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.OpinionUpdatedForOwner(opinion.User.UserName), school);
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.OpinionUpdated(opinion.User.UserName, school.Name), school);
return(NoContent());
}
return(BadRequest("Nie udało się zaktualizować opinii"));
}
public async Task <IActionResult> DeleteLogo(int schoolId)
{
var school = await database.SchoolRepository.Get <School>(schoolId);
if (string.IsNullOrEmpty(school.LogoUrl))
{
return(BadRequest("Brak logo do usunięcia"));
}
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (currentUserId != school.OwnerId && !await rolesService.IsPermitted(RolesPermitted, currentUserId))
{
return(this.Forbidden("Nie jesteś właścicielem tej szkółki"));
}
if (await RemoveLogoUrl(school))
{
await notificationSystem.PushNotificationToUsersByFollows(StaticExpressions.SchoolUpdated(school.Name), school);
return(NoContent());
}
return(BadRequest("Logo nie zostało usunięte"));
}
public async Task <bool> DeleteTrip(int tripId, School school)
{
if (school == null)
{
throw new EntityNotFoundException("Szkółka");
}
var trip = school.Trips.FirstOrDefault(t => t.Id == tripId);
if (trip == null)
{
throw new EntityNotFoundException("Wycieczka");
}
school.Trips.Remove(trip);
if (!await database.Complete())
{
return(false);
}
await notificationSystem.PushNotificationToUsersByTripFollows(StaticExpressions.TripDeleted(school.Name, trip.Name), trip);
return(true);
}
public async Task <bool> SendReport(Report report, ReportMessage reportMessage, User user)
{
if (report == null || user == null || reportMessage == null)
{
throw new EntityNotFoundException();
}
if (user.Reports.Count == 3)
{
return(false);
}
user.Reports.Add(report);
user.ReportMessages.Add(reportMessage);
report.ReportMessages.Add(reportMessage);
if (!await database.Complete())
{
return(false);
}
await notificationSystem.PushNotificationToUsersByRoles(StaticExpressions.NewReportCreated(user.UserName), AdminRoles);
return(true);
}
public async Task <IActionResult> CreateSchool([FromForm] SchoolForCreateDto schoolForCreateDto)
{
if (schoolForCreateDto.Logo != null &&
!filesUploader.IsValidExtension(schoolForCreateDto.Logo.FileName, PhotoExtensions))
{
return(BadRequest("Logo posiada niepoprawny format"));
}
int currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var currentUser = await database.UserRepository.Get <User>(currentUserId);
var school = mapper.Map <School>(schoolForCreateDto);
if (currentUser.Rental != null)
{
school.SetRental(currentUser.Rental);
}
if (await schoolService.CreateSchool(school, currentUserId))
{
await SetLogoUrl(schoolForCreateDto.Logo, school);
await notificationSystem.PushNotification(currentUserId, StaticExpressions.SchoolCreated(school.Name));
await notificationSystem.PushNotificationToUsersByRoles(StaticExpressions.SchoolCreated(school.Owner.UserName, school.Name, school.Id),
RolesPermitted, NotificationType.School);
var schoolToReturn = mapper.Map <SchoolDetailsDto>(school);
return(Ok(schoolToReturn));
}
return(BadRequest("Dodawanie szkółki nie powiodło się"));
}
public async Task <IActionResult> AddRentalOpinion(int rentalId, RentalOpinionForCreateDto rentalOpinionForCreateDto)
{
var rental = await database.RentalRepository.Get <Rental>(rentalId);
var currentUserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (rentalService.UserRentalOpinionExist(currentUserId, rental))
{
return(BadRequest("Nie można dodać kilku opinii"));
}
if (rental.OwnerId == currentUserId)
{
return(BadRequest("Nie można dodać opinii do swojej szkółki"));
}
var rentalOpinion = mapper.Map <RentalOpinion>(rentalOpinionForCreateDto);
if (await rentalService.AddRentalOpinion(currentUserId, rental, rentalOpinion))
{
var rentalOpinionToReturn = mapper.Map <RentalOpinionDetailsDto>(rentalOpinion);
await notificationSystem.PushNotification(rental.OwnerId, StaticExpressions.RentalOpinionCreatedForOwner(rentalOpinion.User.UserName));
return(Ok(rentalOpinionToReturn));
}
return(BadRequest("Nie udało się dodać opinii dla wypożyczalni"));
}
public async Task <bool> CancelMeeting(int meetingId, int userId, int schoolId, int currentUserId, bool isRejected = false)
{
var meeting = await database.UserRepository.Get <Meeting>(meetingId);
var school = await database.SchoolRepository.Get <School>(schoolId);
if (isRejected && currentUserId == meeting.ArrangedBy)
{
return(false);
}
if (currentUserId != meeting.UserId && currentUserId != userId && currentUserId != school.OwnerId)
{
return(false);
}
if (!school.Meetings.Any(m => m.Id == meetingId && m.UserId == userId && m.SchoolId == schoolId))
{
return(false);
}
if (meeting.Accepted && isRejected)
{
return(false);
}
database.UserRepository.Remove(meeting);
if (!await database.Complete())
{
return(false);
}
if (currentUserId == school.OwnerId)
{
if (!isRejected)
{
await notificationSystem.PushNotification(userId, StaticExpressions.MeetingCancelledByOwner(school.Name));
}
else
{
await notificationSystem.PushNotification(userId, StaticExpressions.MeetingRejectedByOwner(school.Name));
}
}
else
{
if (!isRejected)
{
await notificationSystem.PushNotification(school.OwnerId, StaticExpressions.MeetingCancelled);
}
else
{
await notificationSystem.PushNotification(school.OwnerId, StaticExpressions.MeetingRejected);
}
}
return(true);
}
public void Expression_from_static_method_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.Where(StaticExpressions.MethodWithParameter(1));
products.ToList();
}
}
public void Expression_from_static_delegate()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.Where(StaticExpressions.Delegate());
products.ToList();
}
}
public void Expression_from_static_delegate_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.Where(StaticExpressions.DelegateWithParameter(1));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_from_static_method_with_variable()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.Where(StaticExpressions.MethodWithVariable());
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Non_expression_embedded_static_method_throws()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => p.Id == StaticExpressions.NonExpressionMethod());
Assert.Throws <NotSupportedException>(() => products.ToList());
}
}
public void Expression_embedded_static_delegate_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.DelegateWithParameter(1))
.Contains(p));
products.ToList();
}
}
public void Expression_embedded_static_delegate()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.Delegate())
.Contains(p));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_embedded_static_method_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.MethodWithParameter(1))
.Contains(p));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Non_expression_embedded_static_delegate_throws()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products
.Where(p => p.Id == StaticExpressions.NonExpressionDelegate());
Assert.Throws <NotSupportedException>(() => products.ToList());
}
}
public void Expression_embedded_static_method_with_variable()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.MethodWithVariable())
.Contains(p));
products.ToList();
}
}
public async Task <bool> DenyRental(Rental rental)
{
if (rental == null)
{
return(false);
}
database.AdminRepository.Remove <Rental>(rental);
await notificationSystem.PushNotification(rental.OwnerId, StaticExpressions.RentalDenied(rental.Name), NotificationType.Rental);
return(await database.Complete());
}
public async Task <bool> DenySchool(School school)
{
if (school == null)
{
return(false);
}
database.AdminRepository.Remove(school);
await notificationSystem.PushNotification(school.OwnerId, StaticExpressions.SchoolDenied(school.Name), NotificationType.School);
return(true);
}
public async Task <bool> AcceptRental(Rental rental)
{
if (rental == null)
{
return(false);
}
rental.Accept();
await rolesService.AdmitRole(rental.Owner, RoleName.RentalOwner);
await notificationSystem.PushNotification(rental.OwnerId, StaticExpressions.RentalAccepted(rental.Name), NotificationType.Rental);
return(true);
}
public async Task <bool> AcceptSchool(School school)
{
if (school == null)
{
return(false);
}
school.Accept();
await rolesService.AdmitRole(school.Owner, RoleName.SchoolOwner);
await notificationSystem.PushNotification(school.OwnerId, StaticExpressions.SchoolAccepted(school.Name), NotificationType.School);
return(true);
}
private async Task RemindAboutMeetings()
{
var meetingsToRemind = context.Meetings.Where(m => m.DateFrom <= DateTime.Now.AddDays(1) && m.Accepted && !m.Reminded);
var userIds = meetingsToRemind.Select(m => new { m.UserId, m.School.OwnerId });
userIds.ToList().ForEach(ui =>
{
var meeting = meetingsToRemind.FirstOrDefault(m => m.UserId == ui.UserId && m.School.OwnerId == ui.OwnerId);
meeting.Remind();
notificationSystem.PushNotification(ui.UserId, StaticExpressions.MeetingRemind(meeting.School.Name, meeting.DateFrom.ToShortDateString())).Wait();
notificationSystem.PushNotification(ui.OwnerId, StaticExpressions.MeetingRemindForOwner(meeting.DateFrom.ToShortDateString())).Wait();
});
await context.SaveChangesAsync();
}
public async Task <IActionResult> SendChangeEmail(int id, UserToChangeEmailDto userToChangeEmailDto)
{
var user = await accountManager.GetUser(id);
if (await authService.GetUserByEmail(userToChangeEmailDto.Email) != null)
{
return(BadRequest("Użytkownik o takim adresie email już istnieje"));
}
var callbackUrl = await accountManager.GenerateEmailConfirmationCallbackUrl(user, userToChangeEmailDto.Email);
if (await emailSender.SendEmail(StaticExpressions.ChangeEmailEmail(userToChangeEmailDto.Email, user.UserName, callbackUrl)))
{
return(Accepted());
}
throw new AccountException("Wystąpił błąd podczas zmiany adresu email");
}
public async Task <IActionResult> SendResetPassword([FromForm] string email)
{
var user = await authService.GetUserByEmail(email);
if (user == null)
{
return(Accepted());
}
var callbackUrl = await authService.GenerateResetPasswordCallbackUrl(user);
if (await emailSender.SendEmail(StaticExpressions.ResetPasswordEmail(user.Email, user.UserName, callbackUrl)))
{
return(Accepted());
}
throw new AuthorizationException("Wystąpił błąd podczas resetowania hasła");
}
public async Task <bool> ArrangeMeeting(Meeting meeting, int schoolId, int userId, int currentUserId)
{
if (meeting == null)
{
throw new EntityNotFoundException("Spotkanie");
}
var school = await database.UserRepository.Get <School>(schoolId);
var user = await database.UserRepository.Get <User>(userId);
if (currentUserId != userId && currentUserId != school.OwnerId)
{
return(false);
}
if (user.Meetings.Where(m => m.SchoolId == schoolId).Count() > 5)
{
return(false);
}
meeting.SetSchoolAndUserId(school.Id, user.Id);
meeting.SetArrangedBy(currentUserId);
school.Meetings.Add(meeting);
user.Meetings.Add(meeting);
if (!await database.Complete())
{
return(false);
}
if (currentUserId == school.OwnerId)
{
await notificationSystem.PushNotification(user.Id, StaticExpressions.NewMeetingArrangedByOwner(school.Name));
}
else
{
await notificationSystem.PushNotification(school.OwnerId, StaticExpressions.NewMeetingArranged(user.UserName));
}
return(true);
}
