protected override async Task CallTransaction(decimal amount, string description, CreditCard data)
{
try
{
ValidateResult(await _paymentApi.TransactionAsync(amount, description, data));
}
catch (ArgumentNullException argumentException)
{
var exception = new PaymentException(PaymentError.DataIncomplete, "Given data incomplete", argumentException);
Logger.Here().Error(exception, "{CreditCard} data was incomplete", nameof(ApolloCreditCard));
throw exception;
}
catch (ArgumentException argumentException)
{
var exception = new PaymentException(PaymentError.DataInvalid, "Given data not valid", argumentException);
Logger.Here().Error(exception, "{CreditCard} data was invalid", nameof(ApolloCreditCard));
throw exception;
}
catch (NetworkConnectionException networkConnectionException)
{
var exception = new PaymentException(PaymentError.ConnectionLost, "Connection lost", networkConnectionException);
Logger.Here().Error(exception, "Connection was lost during transaction");
throw exception;
}
}
public async Task AddSchedulesForMoviesAsync(DateTime from, DateTime to, IEnumerable <Movie> movies)
{
ValidateDateRange(from, to);
ValidateCollection(movies);
var moviesList = movies.ToList();
var schedules = new List <Schedule>();
var cinemaHalls = (await _cinemaHallDao.FluentSelectAll().QueryAsync()).ToList();
var cinemaHallId = cinemaHalls.Any()
? cinemaHalls.First().Id
: throw new ArgumentNullException(nameof(AddSchedulesForMoviesAsync));
var current = from;
var batchSize = 0;
while (current != to)
{
var scheduleThisDay = RandomGenerator.GenerateRandomNumber(MinSchedulesPerDay, MaxSchedulesPerDay);
var lastStartTime = new DateTime(current.Year, current.Month, current.Day, 0, 0, 0, 0);
var movie = GetRandomMovie(moviesList);
for (var i = 0; i < scheduleThisDay; ++i)
{
Logger.Here().Info("{StartTime} {scheduleThisDay}", lastStartTime, scheduleThisDay);
if (batchSize == BatchSize) //to avoid huge memory consumption flush after batch size is reached
{
Logger.Here().Info("Processing batch with {currentSchedules} {batchSize}", schedules.Count, batchSize);
await AddSchedulesAsync(schedules);
schedules.Clear();
batchSize = 0;
Logger.Here().Info("Batch processed - Reset batch count {currentSchedules} {batchSize}", schedules.Count, batchSize);
}
movie = NewRandomMovie(moviesList, i, movie);
schedules.Add(new Schedule
{
CinemaHallId = cinemaHallId,
MovieId = movie.Id,
Price = GetRandomPrice(lastStartTime.IsWeekend()),
StartTime = lastStartTime
});
if (lastStartTime.WouldExceedDay(movie.Duration + BufferTime))
{
break;
}
lastStartTime = IsFirstStartTime(lastStartTime) ?
lastStartTime.AddHours(BreakTime) :
lastStartTime.AddMinutes(movie.Duration).AddMinutes(BufferTime);
++batchSize;
}
current = current.AddDays(OneDay);
}
if (schedules.Count > 0)
{
await AddSchedulesAsync(schedules);
}
}
public bool IsValid(IEnumerable <SeatDto> seatLayout, IEnumerable <SeatDto> desiredSeats)
{
ValidationHelper.ValidateEnumerableIsNotNullOrEmpty(Logger.Here(), seatLayout, nameof(seatLayout));
ValidationHelper.ValidateEnumerableIsNotNullOrEmpty(Logger.Here(), desiredSeats, nameof(desiredSeats));
var desiredSeatIds = desiredSeats.Select(ds => ds.Id).ToList();
var seats = seatLayout.Where(s => desiredSeatIds.Contains(s.Id))
.ToList();
return(seats.Count() == desiredSeatIds.Count() && seats.All(s => s.State == SeatState.Free));
}
public async Task <UserDto> AddUserAsync(UserDto user)
{
ValidateUserDto(user);
var mappedUser = Map(user);
var cityExist =
await _unitOfWork.RepositoryUser.CityExistAsync(user.Address.PostalCode, user.Address.City);
await _unitOfWork.Transaction().PerformBlock(async() =>
{
if (!cityExist.Exist)
{
var cityId = await _unitOfWork.RepositoryUser.AddCityAsync(mappedUser.Address.City);
ValidateId <UserService, City>(Logger.Here(), cityId);
mappedUser.Address.CityId = cityId;
}
var addressId = await _unitOfWork.RepositoryUser.AddAddressAsync(mappedUser.Address);
ValidateId <UserService, Address>(Logger.Here(), addressId);
mappedUser.AddressId = addressId;
var userId = await _unitOfWork.RepositoryUser.AddUserAsync(mappedUser);
ValidateId <UserService, User>(Logger.Here(), userId);
}).Commit();
return(user);
}
public bool IsValid(IEnumerable <SeatDto> seatLayout, IEnumerable <SeatDto> desiredSeats)
{
ValidationHelper.ValidateEnumerableIsNotNullOrEmpty(Logger.Here(), seatLayout, nameof(seatLayout));
ValidationHelper.ValidateEnumerableIsNotNullOrEmpty(Logger.Here(), desiredSeats, nameof(desiredSeats));
var seatsForReservation = desiredSeats.ToList();
var lowestSeatNo = seatsForReservation.Min(s => s.Number);
var highestSeatNo = seatsForReservation.Max(s => s.Number);
return(Math.Abs(highestSeatNo - lowestSeatNo) + 1 == seatsForReservation.Count());
}
public bool IsValid(IEnumerable <SeatDto> seatData, IEnumerable <SeatDto> desiredSeats)
{
var seatDataList = seatData.ToList();
var desiredSeatsList = desiredSeats.ToList();
ValidationHelper.ValidateEnumerableIsNotNullOrEmpty(Logger.Here(), seatDataList, nameof(seatData));
ValidationHelper.ValidateEnumerableIsNotNullOrEmpty(Logger.Here(), desiredSeatsList, nameof(desiredSeatsList));
var seatLayout = GetSeatLayout(seatDataList, desiredSeatsList);
return(desiredSeatsList.All(seat => ValidateNeighbors(seatLayout, seat.LayoutRow, seat.LayoutColumn)));
}
public async Task <ActionResult <RoleDto> > GetRole()
{
var uuid = JwtHelper.GetUuidFromClaims(HttpContext.User.Claims);
if (uuid == null)
{
Logger.Here().Error("Request with invalid JWT");
return(BadRequestResponse("JWT invalid"));
}
var user = await _service.CreateUserService().GetUserWithAddressByUuidAsync(uuid);
Logger.Here().Info("{Role} extracted from claims for {user}", user.Role, user);
return(user.Role);
}
public async Task TransactionAsync(decimal amount, string description, TPayment paymentData)
{
try
{
Logger.Here().Info("Start payment transaction");
await CallTransaction(amount, description, ConvertPayment(paymentData));
}
catch (PaymentException exception)
{
Logger.Here().Error(exception, "{Error} during payment transaction", nameof(exception.Error));
throw;
}
catch (Exception exception)
{
Logger.Here().Error(exception, "Unknown error during payment transaction");
throw new PaymentException(PaymentError.Unknown, "Unknown error", exception);
}
Logger.Here().Info("Finished payment transaction");
}
private async Task <ReservationDto> TryAddReservationAsync(IEnumerable <SeatDto> seatDtos, long scheduleId, long userId)
{
ValidateEnumerableIsNotNullOrEmpty(Logger, seatDtos, nameof(seatDtos));
var schedule = await _unitOfWork.RepositorySchedule.GetScheduleByIdAsync(scheduleId);
ValidateNull(Logger.Here(), schedule);
var dateTimeUtcNow = DateTime.UtcNow;
ValidateLessOrEquals(Logger.Here(), dateTimeUtcNow, schedule.StartTime);
var user = await _unitOfWork.RepositoryUser.GetUserWithAllReferencesByIdAsync(userId);
ValidateLessOrEquals(Logger.Here(), seatDtos.Count(), user.Role.MaxReservations);
var seatLayout = (await _infrastructureService.GetLayout(Map(schedule)));
var flatLayout = seatLayout.Cast <SeatDto>()
.Where(s => s != null)
.ToList();
ApplyValidation(seatDtos, flatLayout);
var seats = seatDtos.Select(Map).ToList();
var reservationId = await _unitOfWork.RepositoryTicket.AddReservationAsync(seats, scheduleId, userId);
ValidateId <ReservationService, long>(Logger.Here(), reservationId);
return(Map(await _unitOfWork.RepositoryTicket.GetReservationByIdAsync(reservationId)));
}
} //to be able to use Logger and prevent creation of Instances
#endregion
#region StaticMethods
public static async Task <string> FetchStreamUrl(string trailerUrl, string pattern)
{
if (string.IsNullOrWhiteSpace(trailerUrl))
{
return(null);
}
var restClient = new RestClient(trailerUrl);
var request = new RestRequest("#", Method.GET, DataFormat.Json);
var jsonSite = await restClient.ExecuteAsync(request);
var content = Regex.Match(jsonSite.Content, pattern, RegexOptions.IgnoreCase);
if (content.Success)
{
Logger.Here().Info($"Fetched request URL successfully for trailer {trailerUrl}");
return(content.Groups[0].Value.Substring(0, content.Groups[0].Value.Length - 2));
}
return(null);
}
public async Task <ActionResult <IList <CinemaHallDto> > > GetCinemaHalls()
{
Logger.Here().Info(nameof(GetCinemaHalls));
return((await _service.CreateInfrastructureService().GetActiveCinemaHallsAsync()).ToList());
}
public static ActorDto Map(Actor actor)
{
ValidateNull(Logger.Here(), actor);
return(new ActorDto
{
Id = actor.Id,
RowVersion = actor.RowVersion,
LastName = actor.LastName,
FirstName = actor.FirstName
});
}
public async Task <ActionResult <IList <ScheduleDto> > > GetSchedules(DateTime day)
{
Logger.Here().Info("{GetSchedules} from {day}", nameof(GetSchedules), day.ToShortDateString());
return((await GetSchedulesByDay(day)).ToList());
}
public async Task <IEnumerable <SeatDto> > GetActiveSeatsFromCinemaHallByCategoriesAsync(long cinemaHallId,
IEnumerable <long> categoryIds)
{
ValidateNull(Logger.Here(), categoryIds);
return((await _unitOfWork.RepositoryInfrastructure.GetActiveSeatsFromCinemaHallByCategoryAsync(cinemaHallId,
categoryIds))
.Select(Map));
}
public async Task <ActionResult <IEnumerable <GenreDto> > > GetGenre()
{
Logger.Here().Info("{GetActors}", nameof(GetActors));
return((await _service.CreateMovieService().GetActiveGenresAsync()).ToList());
}
public async Task <ScheduleDto> AddScheduleAsync(ScheduleDto newSchedule)
{
ValidateNull(Logger.Here(), newSchedule);
var id = await _unitOfWork.RepositorySchedule.AddScheduleAsync(Map(newSchedule));
if (id <= 0L)
{
return(null);
}
newSchedule.Id = id;
return(newSchedule);
}