public static string ImportStations(StationsDbContext context, string jsonString)
{
var stations = new List <Station>();
var result = new StringBuilder();
var objStations = JsonConvert.DeserializeObject <StationDto[]>(jsonString);
foreach (var objStation in objStations)
{
var ifStationExists = stations.Any(s => s.Name == objStation.Name);
if (!IsValid(objStation) || ifStationExists)
{
result.AppendLine(FailureMessage);
continue;
}
if (objStation.Town == null)
{
objStation.Town = objStation.Name;
}
stations.Add(Mapper.Map <Station>(objStation));
result.AppendLine(string.Format(SuccessMessage, objStation.Name));
}
context.AddRange(stations);
context.SaveChanges();
return(result.ToString());
}
public static string ImportCards(StationsDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportDto.CardDto[]), new XmlRootAttribute("Cards"));
ImportDto.CardDto[] deserializedCards = (ImportDto.CardDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
StringBuilder sb = new StringBuilder();
List <CustomerCard> cards = new List <CustomerCard>();
foreach (var cardDto in deserializedCards)
{
if (!IsValid(cardDto))
{
sb.AppendLine(FailureMessage);
continue;
}
CustomerCard card = new CustomerCard()
{
Name = cardDto.Name,
Age = cardDto.Age,
Type = cardDto.CardType,
};
cards.Add(card);
sb.AppendLine(string.Format(SuccessMessage, cardDto.Name));
}
context.AddRange(cards);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportTrains(StationsDbContext context, string jsonString)
{
var trainsFromJson = JsonConvert.DeserializeObject <TrainDto[]>(jsonString);
var result = new StringBuilder();
var validTrains = new List <Train>();
foreach (var train in trainsFromJson)
{
string trainNumber = train.TrainNumber;
var type = Enum.Parse <TrainType>(train.Type ?? "HighSpeed");
var seats = train.Seats;
var isTrainNumberValid = !String.IsNullOrWhiteSpace(trainNumber) &&
trainNumber?.Length <= 10 &&
!validTrains.Any(t => t.TrainNumber == trainNumber);
var areSeatsValid = seats
.All(s => context.SeatingClasses
.Any(sc => sc.Name == s.Name && sc.Abbreviation == s.Abbreviation) &&
s.Quantity != null &&
s.Quantity >= 0);
if (!isTrainNumberValid || !areSeatsValid)
{
result.AppendLine(FailureMessage);
continue;
}
var currentTrain = new Train()
{
TrainNumber = trainNumber,
Type = type,
TrainSeats = new List <TrainSeat>()
};
foreach (var seat in train.Seats)
{
var currentSeat = new TrainSeat()
{
Train = currentTrain,
SeatingClass = context.SeatingClasses.SingleOrDefault(sc => sc.Name == seat.Name && sc.Abbreviation == seat.Abbreviation),
Quantity = seat.Quantity.Value
};
currentTrain.TrainSeats.Add(currentSeat);
}
validTrains.Add(currentTrain);
result.AppendLine(string.Format(SuccessMessage, train.TrainNumber));
}
context.AddRange(validTrains);
context.SaveChanges();
return(result.ToString().TrimEnd());
}
public static string ImportStations(StationsDbContext context, string jsonString)
{
var sb = new StringBuilder();
var jsonStations = JsonConvert.DeserializeObject <StationDto[]>(jsonString);
var stations = new List <Station>();
foreach (var station in jsonStations)
{
if (!IsValid(station))
{
sb.AppendLine(FailureMessage);
continue;
}
string town = station.Town;
string name = station.Name;
bool nameExist = stations.Any(s => s.Name == name);
if (nameExist)
{
sb.AppendLine(FailureMessage);
continue;
}
if (town == null)
{
town = name;
}
Station currentStation = new Station
{
Name = name,
Town = town,
};
stations.Add(currentStation);
sb.AppendLine(String.Format(SuccessMessage, name));
}
context.AddRange(stations);
context.SaveChanges();
string result = sb.ToString();
return(result);
}
public static string ImportStations(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
StationDto[] jsonStation = JsonConvert.DeserializeObject <StationDto[]>(jsonString);
List <Station> stations = new List <Station>();
foreach (var s in jsonStation)
{
string name = s.Name;
string townName = s.Town;
if (s.Town == null)
{
townName = name;
}
StationDto dto = new StationDto()
{
Name = name,
Town = townName,
};
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (stations.Any(x => x.Name == s.Name))
{
sb.AppendLine(FailureMessage);
continue;
}
Station station = Mapper.Map <Station>(dto);
stations.Add(station);
sb.AppendLine(string.Format(SuccessMessage, s.Name));
}
context.AddRange(stations);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var sb = new StringBuilder();
var jsonSeats = JsonConvert.DeserializeObject <SeatingClassesDto[]>(jsonString);
var seats = new List <SeatingClass>();
foreach (var seat in jsonSeats)
{
if (!IsValid(seat))
{
sb.AppendLine(FailureMessage);
continue;
}
bool seatingClassExist =
seats.Any(sc => sc.Name == seat.Name || sc.Abbreviation == seat.Abbreviation);
if (seatingClassExist)
{
sb.AppendLine(FailureMessage);
continue;
}
string seatName = seat.Name;
SeatingClass currentSeat = new SeatingClass
{
Name = seatName,
Abbreviation = seat.Abbreviation
};
seats.Add(currentSeat);
sb.AppendLine(String.Format(SuccessMessage, seatName));
}
context.AddRange(seats);
context.SaveChanges();
string result = sb.ToString();
return(result);
}
public static string ImportCards(StationsDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(CardDto[]), new XmlRootAttribute("Cards"));
var deserializedCards = (CardDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var sb = new StringBuilder();
var validCards = new List <CustomerCard>();
foreach (var dto in deserializedCards)
{
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (dto.Type == null)
{
dto.Type = "Normal";
}
var cardTyoe = Enum.Parse <CardType>(dto.Type);
var card = new CustomerCard()
{
Name = dto.Name,
Age = dto.Age,
Type = cardTyoe
};
validCards.Add(card);
sb.AppendLine(string.Format(SuccessMessage, dto.Name));
}
context.AddRange(validCards);
context.SaveChanges();
var result = sb.ToString().Trim();
return(result);
}
public static string ImportCards(StationsDbContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(CardDto[]), new XmlRootAttribute("Cards"));
CardDto[] deserializer =
(CardDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
List <CustomerCard> validCards = new List <CustomerCard>();
foreach (var cardDto in deserializer)
{
if (!isValid(cardDto))
{
sb.AppendLine(FailureMessage);
continue;
}
CardType cardType = Enum.TryParse <CardType>(cardDto.CardType, out var card) ? card : CardType.Normal;
var customerCard = new CustomerCard
{
Name = cardDto.Name,
Type = cardType,
Age = cardDto.Age
};
validCards.Add(customerCard);
sb.AppendLine(string.Format(SuccessMessage, cardDto.Name));
}
context.AddRange(validCards);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
SeatingClassDto[] jsonSeatingClasses = JsonConvert.DeserializeObject <SeatingClassDto[]>(jsonString);
List <SeatingClass> stations = new List <SeatingClass>();
foreach (var s in jsonSeatingClasses)
{
SeatingClassDto dto = new SeatingClassDto()
{
Name = s.Name,
Abbreviation = s.Abbreviation,
};
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (stations.Any(x => x.Name == s.Name || x.Abbreviation == s.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
SeatingClass seatingClass = Mapper.Map <SeatingClass>(dto);
stations.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, s.Name));
}
context.AddRange(stations);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportTrips(StationsDbContext context, string jsonString)
{
var sb = new StringBuilder();
var jsonTrips = JsonConvert.DeserializeObject <TripDto[]>(jsonString, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var trips = new List <Trip>();
foreach (var trip in jsonTrips)
{
if (!IsValid(trip))
{
sb.AppendLine(FailureMessage);
continue;
}
var train = context.Trains.FirstOrDefault(t => t.TrainNumber == trip.Train);
var arrivalStation = context.Stations.FirstOrDefault(s => s.Name == trip.DestinationStation);
var departerStation = context.Stations.FirstOrDefault(s => s.Name == trip.OriginStation);
if (train == null || arrivalStation == null || departerStation == null)
{
sb.AppendLine(FailureMessage);
continue;
}
DateTime departerTime = DateTime.ParseExact(trip.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
DateTime arrivalTime = DateTime.ParseExact(trip.ArrivalTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
if (departerTime > arrivalTime)
{
sb.AppendLine(FailureMessage);
continue;
}
TimeSpan timeDifference;
if (trip.TimeDifference != null)
{
timeDifference = TimeSpan.ParseExact(trip.TimeDifference, @"hh\:mm", CultureInfo.InvariantCulture);
}
Trip currentTrip = new Trip
{
Train = train,
DestinationStation = arrivalStation,
OriginStation = departerStation,
DepartureTime = departerTime,
ArrivalTime = arrivalTime,
TimeDifference = timeDifference,
Status = trip.Status
};
trips.Add(currentTrip);
sb.AppendLine(String.Format($"Trip from {departerStation.Name} to {arrivalStation.Name} imported."));
}
context.AddRange(trips);
context.SaveChanges();
string result = sb.ToString();
return(result);
}
public static string ImportTrips(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
ImportDto.TripDto[] tripsDto = JsonConvert.DeserializeObject <ImportDto.TripDto[]>(jsonString, new JsonSerializerSettings
{
DefaultValueHandling = DefaultValueHandling.Ignore,
});
List <Trip> trips = new List <Trip>();
foreach (var tripDto in tripsDto)
{
if (!IsValid(tripDto))
{
sb.AppendLine(FailureMessage);
continue;
}
DateTime arrivalTime = DateTime.ParseExact(tripDto.ArrivalTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
DateTime departureTime = DateTime.ParseExact(tripDto.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
Train train = context.Trains.SingleOrDefault(x => x.TrainNumber == tripDto.Train);
Station originStation = context.Stations.SingleOrDefault(x => x.Name == tripDto.OriginStation);
Station destinationStation = context.Stations.SingleOrDefault(x => x.Name == tripDto.DestinationStation);
if (train == null || originStation == null || destinationStation == null)
{
sb.AppendLine(FailureMessage);
continue;
}
if (arrivalTime < departureTime)
{
sb.AppendLine(FailureMessage);
continue;
}
TripStatus tripStatus = TripStatus.OnTime;
if (tripDto.Status != null)
{
tripStatus = tripDto.Status.Value;
}
TimeSpan?timeDifference = null;
if (tripDto.TimeDifference != null)
{
timeDifference = TimeSpan.ParseExact(tripDto.TimeDifference, @"hh\:mm", CultureInfo.InvariantCulture);
}
Trip trip = new Trip
{
Train = train,
OriginStation = originStation,
DestinationStation = destinationStation,
ArrivalTime = arrivalTime,
DepartureTime = departureTime,
Status = tripStatus,
TimeDifference = timeDifference,
};
trips.Add(trip);
sb.AppendLine(string.Format($"Trip from {tripDto.OriginStation} to {tripDto.DestinationStation} imported."));
}
context.AddRange(trips);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportTrains(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
TrainDto[] trainsDto = JsonConvert.DeserializeObject <TrainDto[]>(jsonString, new JsonSerializerSettings
{
DefaultValueHandling = DefaultValueHandling.Ignore,
});
List <Train> trains = new List <Train>();
foreach (var trainDto in trainsDto)
{
if (!IsValid(trainDto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (trains.Any(x => x.TrainNumber == trainDto.TrainNumber))
{
sb.AppendLine(FailureMessage);
continue;
}
if (!trainDto.Seats.All(IsValid))
{
sb.AppendLine(FailureMessage);
continue;
}
TrainType?trainType = trainDto.Type;
if (trainDto.Type == null)
{
trainType = TrainType.HighSpeed;
}
bool dtoClasessIsValid = trainDto.Seats.All(t => context.SeatingClasses.Any(c => c.Name == t.Name && c.Abbreviation == t.Abbreviation));
if (!dtoClasessIsValid)
{
sb.AppendLine(FailureMessage);
continue;
}
TrainSeat[] trainSeats = trainDto.Seats.Select(s => new TrainSeat
{
SeatingClass = context.SeatingClasses.SingleOrDefault(x => x.Name == s.Name && x.Abbreviation == s.Abbreviation),
Quantity = s.Quantity.Value,
})
.ToArray();
Train train = new Train()
{
TrainNumber = trainDto.TrainNumber,
Type = trainType,
TrainSeats = trainSeats,
};
trains.Add(train);
sb.AppendLine(string.Format(SuccessMessage, trainDto.TrainNumber));
}
context.AddRange(trains);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportTickets(StationsDbContext context, string xmlString)
{
var sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(TicketDto[]), new XmlRootAttribute("Tickets"));
var ticketDtos = (TicketDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var tickets = new List <Ticket>();
foreach (var ticket in ticketDtos)
{
if (!IsValid(ticket))
{
sb.AppendLine(FailureMessage);
continue;
}
DateTime departerTime =
DateTime.ParseExact(ticket.Trip.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var trip = context.Trips
.FirstOrDefault(t =>
t.OriginStation.Name == ticket.Trip.OriginStation &&
t.DestinationStation.Name == ticket.Trip.DestinationStation &&
t.DepartureTime == departerTime);
if (trip == null)
{
sb.AppendLine(FailureMessage);
continue;
}
CustomerCard card = null;
if (ticket.Card != null)
{
card = context.Cards
.FirstOrDefault(c => c.Name == ticket.Card.Name);
if (card == null)
{
sb.AppendLine(FailureMessage);
continue;
}
}
var abbreviation = ticket.Seat.Substring(0, 2);
var quantity = int.Parse(ticket.Seat.Substring(2));
var abbreviationExist = context.SeatingClasses.Any(sc => sc.Abbreviation == abbreviation);
if (!abbreviationExist)
{
sb.AppendLine(FailureMessage);
continue;
}
var availableSeats = trip.Train.TrainSeats.Any(s =>
s.SeatingClass.Abbreviation == abbreviation && s.Quantity >= quantity);
if (!availableSeats)
{
sb.AppendLine(FailureMessage);
continue;
}
var currentTicket = new Ticket
{
SeatingPlace = ticket.Seat,
Trip = trip,
CustomerCard = card,
Price = ticket.Price
};
tickets.Add(currentTicket);
sb.AppendLine(String.Format($"Ticket from {trip.OriginStation.Name} to {trip.DestinationStation.Name} " +
$"departing at {trip.DepartureTime.ToString(@"dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)} imported."));
}
context.AddRange(tickets);
context.SaveChanges();
string result = sb.ToString();
return(result);
}
public static string ImportTrips(StationsDbContext context, string jsonString)
{
var tripsJson = JsonConvert.DeserializeObject <TripDto[]>(jsonString, new JsonSerializer()
{
NullValueHandling = NullValueHandling.Ignore
});
var sb = new StringBuilder();
var trips = new List <Trip>();
foreach (var t in tripsJson)
{
var train = context.Trains.SingleOrDefault(r => r.TrainNumber == t.Train);
var originStation = context.Stations.SingleOrDefault(s => s.Name == t.OriginStation);
var destinationStation = context.Stations.SingleOrDefault(s => s.Name == t.DestinationStation);
if (train == null || originStation == null || destinationStation == null || originStation == destinationStation)
{
sb.AppendLine(FailureMessage);
continue;
}
if (string.IsNullOrWhiteSpace(t.DepartureTime.ToString()) || string.IsNullOrWhiteSpace(t.ArrivalTime.ToString()))
{
sb.AppendLine(FailureMessage);
continue;
}
var depTime = DateTime.ParseExact(t.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var arTime = DateTime.ParseExact(t.ArrivalTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
if (depTime > arTime)
{
sb.AppendLine(FailureMessage);
continue;
}
var status = Enum.Parse <TripStatus>(t.Status);
var timeDiff = TimeSpan.Zero;
if (!string.IsNullOrEmpty(t.TimeDifference))
{
timeDiff = TimeSpan.ParseExact("00:00", "HH:mm", CultureInfo.InvariantCulture);
if (status != TripStatus.OnTime)
{
timeDiff = TimeSpan.ParseExact(t.TimeDifference, "HH:mm", CultureInfo.InvariantCulture);
}
}
var validTrip = new Trip()
{
Train = train,
OriginStation = originStation,
DestinationStation = destinationStation,
DepartureTime = depTime,
ArrivalTime = arTime,
Status = status,
TimeDifference = timeDiff
};
trips.Add(validTrip);
sb.AppendLine(string.Format(SuccessMessage, $"{t.OriginStation} to {t.DestinationStation}"));
}
context.AddRange(trips);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportTrains(StationsDbContext context, string jsonString)
{
var sb = new StringBuilder();
var jsonTrains = JsonConvert.DeserializeObject <TrainDto[]>(jsonString, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var trains = new List <Train>();
foreach (var train in jsonTrains)
{
if (!IsValid(train))
{
sb.AppendLine(FailureMessage);
continue;
}
bool trainALreadyExist = trains.Any(t => t.TrainNumber == train.TrainNumber);
if (trainALreadyExist)
{
sb.AppendLine(FailureMessage);
continue;
}
bool areSeatsValid = train.Seats.All(IsValid);
if (!areSeatsValid)
{
sb.AppendLine(FailureMessage);
continue;
}
bool areSeatsContaintedInTheDatabase = train.Seats.All(s =>
context.SeatingClasses.Any(sc => sc.Abbreviation == s.Abbreviation && sc.Name == s.Name));
if (!areSeatsContaintedInTheDatabase)
{
sb.AppendLine(FailureMessage);
continue;
}
var trainType = Enum.Parse <TrainType>(train.Type);
var trainSeats = train.Seats.Select(s => new TrainSeat
{
SeatingClass = context.SeatingClasses.FirstOrDefault(sc => sc.Name == s.Name && sc.Abbreviation == s.Abbreviation),
Quantity = s.Quantity.Value
})
.ToArray();
string trainNumber = train.TrainNumber;
var currentTrain = new Train
{
TrainNumber = trainNumber,
Type = trainType,
TrainSeats = trainSeats
};
trains.Add(currentTrain);
sb.AppendLine(String.Format(SuccessMessage, trainNumber));
}
context.AddRange(trains);
context.SaveChanges();
string result = sb.ToString();
return(result);
}
public static string ImportTickets(StationsDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(TicketDto[]), new XmlRootAttribute("Tickets"));
TicketDto[] deserializedCards = (TicketDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
StringBuilder sb = new StringBuilder();
List <Ticket> tickets = new List <Ticket>();
foreach (var ticketDto in deserializedCards)
{
if (!IsValid(ticketDto))
{
sb.AppendLine(FailureMessage);
continue;
}
DateTime date = DateTime.ParseExact(ticketDto.Trip.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
Trip trip = context.Trips.SingleOrDefault(x => x.DestinationStation.Name == ticketDto.Trip.DestinationStation &&
x.OriginStation.Name == ticketDto.Trip.OriginStation && x.DepartureTime == date);
if (trip == null)
{
sb.AppendLine(FailureMessage);
continue;
}
CustomerCard card = null;
if (ticketDto.Card != null)
{
card = context.Cards.SingleOrDefault(x => x.Name == ticketDto.Card.Name);
if (card == null)
{
sb.AppendLine(FailureMessage);
continue;
}
}
var seatingClassAbbreviation = ticketDto.SeatingPlace.Substring(0, 2);
var quantity = int.Parse(ticketDto.SeatingPlace.Substring(2));
var seatExists = context.Trains
.Select(x => x.TrainSeats
.SingleOrDefault(s => s.SeatingClass.Abbreviation == seatingClassAbbreviation && quantity <= s.Quantity));
if (seatExists == null)
{
sb.AppendLine(FailureMessage);
continue;
}
Ticket ticket = new Ticket()
{
Price = ticketDto.Price,
SeatingPlace = ticketDto.SeatingPlace,
Trip = trip,
CustomerCard = card,
};
tickets.Add(ticket);
sb.AppendLine($"Ticket from {ticketDto.Trip.OriginStation} to {ticketDto.Trip.DestinationStation} departing at {ticket.Trip.DepartureTime} imported.");
}
context.AddRange(tickets);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportTrips(StationsDbContext context, string jsonString)
{
var trips = new List <Trip>();
var result = new StringBuilder();
var objTrips = JsonConvert.DeserializeObject <TripDto[]>(jsonString, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
foreach (var objTrip in objTrips)
{
if (!IsValid(objTrip))
{
result.AppendLine(FailureMessage);
continue;
}
var ifDeprTimeParsed = DateTime.TryParseExact(objTrip.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out DateTime departureTime);
var ifArrTimeParsed = DateTime.TryParseExact(objTrip.ArrivalTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out DateTime arrivalTime);
if (!ifDeprTimeParsed || !ifArrTimeParsed ||
departureTime > arrivalTime)
{
result.AppendLine(FailureMessage);
continue;
}
var train = context.Trains.SingleOrDefault(t => t.TrainNumber == objTrip.Train);
var originStation = context.Stations.SingleOrDefault(
s => s.Name == objTrip.OriginStation);
var destinationStation = context.Stations.SingleOrDefault(s => s.Name == objTrip.DestinationStation);
if (train == null ||
originStation == null || destinationStation == null)
{
result.AppendLine(FailureMessage);
continue;
}
TimeSpan timeDifference;
if (objTrip.TimeDifference != null)
{
timeDifference = TimeSpan.ParseExact(objTrip.TimeDifference, @"hh\:mm", CultureInfo.InvariantCulture);
}
var trip = new Trip
{
Train = train,
OriginStation = originStation,
DestinationStation = destinationStation,
DepartureTime = departureTime,
ArrivalTime = arrivalTime,
Status = Enum.Parse <TripStatus>(objTrip.Status),
TimeDifference = timeDifference
};
trips.Add(trip);
result.AppendLine($"Trip from {trip.OriginStation.Name} to {trip.DestinationStation.Name} imported.");
}
context.AddRange(trips);
context.SaveChanges();
return(result.ToString());
}
public static string ImportTrains(StationsDbContext context, string jsonString)
{
var trainsJson = JsonConvert.DeserializeObject <TrainAndSeatsDto[]>(jsonString, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
var trains = new List <Train>();
var sb = new StringBuilder();
foreach (var t in trainsJson)
{
if (string.IsNullOrWhiteSpace(t.TrainNumber))
{
sb.AppendLine(FailureMessage);
continue;
}
if (t.TrainNumber.Length > 10)
{
sb.AppendLine(FailureMessage);
continue;
}
if (trains.Any(n => n.TrainNumber == t.TrainNumber))
{
sb.AppendLine(FailureMessage);
continue;
}
if (t.Seats.Count() == 0)
{
sb.AppendLine(FailureMessage);
continue;
}
var seats = new List <TrainSeat>();
foreach (var s in t.Seats)
{
var seatClasses = context.SeatingClasses;
if (string.IsNullOrWhiteSpace(s.Name) || string.IsNullOrWhiteSpace(s.Abbreviation))
{
sb.AppendLine(FailureMessage);
break;
}
if (!seatClasses.Any(sc => sc.Name == s.Name && sc.Abbreviation == s.Abbreviation) || s.Quantity < 0)
{
sb.AppendLine(FailureMessage);
break;
}
int seatingClassId = context.SeatingClasses.Where(sc => sc.Name == s.Name && sc.Abbreviation == s.Abbreviation).SingleOrDefault().Id;
var validSeats = Mapper.Map <TrainSeat>(s);
validSeats.SeatingClassId = seatingClassId;
if (seats.Any(n => n == validSeats))
{
sb.AppendLine(FailureMessage);
break;
}
seats.Add(validSeats);
}
if (seats.Count < t.Seats.Count())
{
continue;
}
var type = TrainType.HighSpeed;
if (!string.IsNullOrWhiteSpace(t.Type))
{
if (t.Type == "Freight")
{
type = TrainType.Freight;
}
else if (t.Type == "LongDistance")
{
type = TrainType.LongDistance;
}
else
{
type = TrainType.HighSpeed;
}
}
var train = new Train()
{
TrainNumber = t.TrainNumber,
Type = type,
TrainSeats = seats.Select(s => new TrainSeat
{
Quantity = s.Quantity,
SeatingClassId = s.SeatingClassId
}).ToArray()
};
trains.Add(train);
sb.AppendLine(string.Format(SuccessMessage, $"{train.TrainNumber}"));
}
context.AddRange(trains);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportTickets(StationsDbContext context, string xmlString)
{
var sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(TicketDto[]), new XmlRootAttribute("Tickets"));
var deserializedTickets = (TicketDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var validTickets = new List <Ticket>();
foreach (var item in deserializedTickets)
{
var departureTime = DateTime.ParseExact(item.Trip.DepartureTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None);
var trip = context.Trips
.Include(e => e.OriginStation)
.Include(e => e.DestinationStation)
.Include(e => e.Train)
.ThenInclude(e => e.TrainSeats)
.SingleOrDefault(e => e.DepartureTime == departureTime && e.DestinationStation.Name == item.Trip.DestinationStation && e.OriginStation.Name == item.Trip.OriginStation);
if (trip == null)
{
sb.AppendLine(FailureMessage);
continue;
}
if (!IsValid(item))
{
sb.AppendLine(FailureMessage);
continue;
}
var searchedAbbreviationArr = item.Seat.Take(2).ToArray();
var searchedAbbreviation = string.Join("", searchedAbbreviationArr);
var placeNumber = int.Parse(string.Join("", item.Seat.Skip(2).ToArray()));
var seatExists = trip.Train.TrainSeats
.SingleOrDefault(s => s.SeatingClass.Abbreviation == searchedAbbreviation && placeNumber <= s.Quantity);
if (seatExists == null)
{
sb.AppendLine(FailureMessage);
continue;
}
CustomerCard card = null;
if (item.Card != null)
{
card = context.Cards.SingleOrDefault(c => c.Name == item.Card.Name);
if (card == null)
{
sb.AppendLine(FailureMessage);
continue;
}
}
var ticket = new Ticket()
{
CustomerCard = card,
Price = item.Price,
Trip = trip,
SeatingPlace = item.Seat
};
validTickets.Add(ticket);
sb.AppendLine($"Ticket from {item.Trip.OriginStation} to {item.Trip.DestinationStation}" +
$" departing at {departureTime} imported.");
}
context.AddRange(validTickets);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}