private static Trip GetTripOrNull(TravellingContext context, TripForTicketDto trip, DateTime date)
{
return(context.Trips.SingleOrDefault(t => t.OriginStation.Name == trip.OriginStation &&
t.DestinationStation.Name == trip.DestinationStation &&
string.Compare(t.DepartureTime.ToString("dd/MM/yyyy HH:mm"), date.ToString("dd/MM/yyyy HH:mm")) == 0
));
}
internal static bool IsValidSeat(TravellingContext context, Ticket ticket)
{
var train = context.Trains.FirstOrDefault(t => t.TrainNumber == ticket.Trip.Train.TrainNumber);
var seatAbbreviature = ticket.SeatingPlace.Substring(0, 2);
var successNumberParse = int.TryParse(ticket.SeatingPlace.Substring(2), out int number);
if (!successNumberParse)
{
return(false);
}
var trainSeat = train.TrainSeatClasses.FirstOrDefault(tsc => tsc.SeatingClass.Abbreviation == seatAbbreviature);
if (trainSeat == null)
{
return(false);
}
var numberMatch = number <= trainSeat.Quantity;
if (!numberMatch)
{
return(false);
}
return(true);
}
public static string ImportPersonalCards(TravellingContext context)
{
var sb = new StringBuilder();
var cardsPath = "../../../../resourses/cards.xml";
var cardsReader = new StreamReader(cardsPath);
var serializer = new XmlSerializer(typeof(CardDto[]), new XmlRootAttribute("Cards"));
var cardsDtos = (CardDto[])serializer.Deserialize(cardsReader);
var validCards = new List <CustomerCard>();
foreach (var cardDto in cardsDtos)
{
if (!ValidateEntity.IsValid(cardDto))
{
sb.AppendLine("Invalid card");
continue;
}
var validCard = new CustomerCard
{
Name = cardDto.Name,
Age = cardDto.Age,
};
if (cardDto.CardType != null)
{
validCard.CardType = cardDto.CardType.Value;
}
validCards.Add(validCard);
sb.AppendLine($"Record {validCard.Name} successfully imported.");
}
context.CustomerCards.AddRange(validCards);
context.SaveChanges();
return(sb.ToString().TrimEnd('\r', '\n'));
}
public static string ImportStations(TravellingContext context)
{
var stationsPath = "../../../../resourses/stations.json";
var reader = new StreamReader(stationsPath);
var sb = new StringBuilder();
string json = reader.ReadToEnd();
var stationsToCheck = JsonConvert.DeserializeObject <StationDto[]>(json).ToHashSet <StationDto>(new SameStationsComparer());
var stationsToImport = new List <Station>();
foreach (var stationToCheck in stationsToCheck)
{
if (!ValidateEntity.IsValid(stationToCheck))
{
sb.AppendLine("InvalidDataFormat");
continue;
}
if (stationToCheck.Town == null)
{
stationToCheck.Town = stationToCheck.Name;
}
var station = new Station
{
Name = stationToCheck.Name,
Town = stationToCheck.Town
};
stationsToImport.Add(station);
sb.AppendLine($"Record {stationToCheck.Name} successfully imported.");
}
context.Stations.AddRange(stationsToImport.ToList());
context.SaveChanges();
return(sb.ToString().TrimEnd('\n', '\r'));
}
static void Main(string[] args)
{
using (var context = new TravellingContext())
{
context.Database.EnsureDeleted();
context.Database.Migrate();
string imoprtSessionsresult = Deserializer.ImportStations(context);
Console.WriteLine(imoprtSessionsresult);
string imoprtClassesResult = Deserializer.ImportClasses(context);
Console.WriteLine(imoprtClassesResult);
string imoprtTrainsResult = Deserializer.ImportTrains(context);
Console.WriteLine(imoprtTrainsResult);
string imoprtTripsResult = Deserializer.ImportTrips(context);
Console.WriteLine(imoprtTripsResult);
string imoprtPersonCardsResult = Deserializer.ImportPersonalCards(context);
Console.WriteLine(imoprtPersonCardsResult);
string imoprtTicketsResult = Deserializer.ImportTicketsCards(context);
Console.WriteLine(imoprtTicketsResult);
string delayedTrainsJsonString = Serializer.DelayedTrainsSerialize(context);
Console.WriteLine(delayedTrainsJsonString);
string cardsXmlString = Serializer.CardsAndCustomersSerialize(context);
Console.WriteLine(cardsXmlString);
}
}
public static string CardsAndCustomersSerialize(TravellingContext context)
{
Console.WriteLine("Insert the card type please:");
var cardTypeString = Console.ReadLine();
var cardsForExport = context.Tickets
.Where(t => t.PersonalCard.CardType.ToString() == cardTypeString)
.GroupBy(t => t.PersonalCard)
.ToArray()
.Select(kvp => new CardForExport
{
Name = kvp.Key.Name,
Type = kvp.Key.CardType.ToString(),
Tickets = kvp.Select(tr => new TicketForExport
{
OriginStation = tr.Trip.OriginStation.Name,
DestinationStation = tr.Trip.DestinationStation.Name,
DepartureTime = tr.Trip.DepartureTime.ToString()
})
.ToArray()
}
)
.OrderBy(f => f.Name)
.ToArray();
var xmlNameSpaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
XmlSerializer serializer = new XmlSerializer(typeof(CardForExport[]), new XmlRootAttribute("Cards"));
var path = "../../../../cards.xml";
var writer = new StreamWriter(path);
serializer.Serialize(writer, cardsForExport, xmlNameSpaces);
writer.Close();
Process.Start("notepad.exe", path);
return(File.ReadAllText(path));
}
public static string ImportClasses(TravellingContext context)
{
var classesPath = "../../../../resourses/classes.json";
var classesReader = new StreamReader(classesPath);
var sb = new StringBuilder();
string json = classesReader.ReadToEnd();
var classesToCheck = JsonConvert.DeserializeObject <ClassDto[]>(json).ToHashSet <ClassDto>(new SameClassesComparer());
var classesToImport = new List <SeatingClass>();
foreach (var classToCheck in classesToCheck)
{
if (!ValidateEntity.IsValid(classToCheck))
{
sb.AppendLine("InvalidDataFormat");
continue;
}
var currentClass = new SeatingClass
{
Name = classToCheck.Name,
Abbreviation = classToCheck.Abbreviation
};
classesToImport.Add(currentClass);
sb.AppendLine($"Record {currentClass.Name} successfully imported.");
}
context.SeatingClasses.AddRange(classesToImport);
context.SaveChanges();
return(sb.ToString().TrimEnd('\n', '\r'));
}
public static string DelayedTrainsSerialize(TravellingContext context)
{
Console.WriteLine("Please insert date with dd/MM/yyyy format");
var dateTimeString = Console.ReadLine();
var date = DateTime.ParseExact(dateTimeString, "dd/MM/yyyy", CultureInfo.InvariantCulture);
var delayedTrains = context.Trips
.Where(tr => tr.Status == TripStatus.Delayed &&
tr.DepartureTime.CompareTo(date) < 1)
.GroupBy(tr => tr.Train.TrainNumber)
.ToList()
.Select(tr => new
{
TrainNumber = tr.Key,
DelayedTimes = tr.Count(),
MaxDelayedTime = tr.Max(t => t.TimeDifference)
})
.OrderByDescending(t => t.DelayedTimes)
.ThenByDescending(t => t.MaxDelayedTime)
.ThenBy(t => t.TrainNumber)
.ToList();
;
string jsonString = JsonConvert.SerializeObject(delayedTrains, Newtonsoft.Json.Formatting.Indented);
var fileName = $"delayed-trips-{date.ToString("dd-MM-yyyy")}.json";
var path = $"../../../../{fileName}";
File.WriteAllText(path, jsonString);
return(jsonString);
}
public static string ImportTicketsCards(TravellingContext context)
{
var sb = new StringBuilder();
var ticketsPath = "../../../../resourses/tickets.xml";
var ticketsReader = new StreamReader(ticketsPath);
var serializer = new XmlSerializer(typeof(TicketDto[]), new XmlRootAttribute("Tickets"));
var ticketsDtos = (TicketDto[])serializer.Deserialize(ticketsReader);
var validTickets = new List <Ticket>();
foreach (var ticketDto in ticketsDtos)
{
if (!ValidateEntity.IsValid(ticketDto))
{
sb.AppendLine("Invalid ticket");
continue;
}
var isDateValid = DateTime.TryParseExact(ticketDto.Trip.DepartureTime,
"dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime date);
if (!isDateValid)
{
sb.AppendLine("InvalidDate!!");
continue;
}
var trip = GetTripOrNull(context, ticketDto.Trip, date);
if (trip == null)
{
sb.AppendLine("InvalidTrip!!!");
continue;
}
var hasCard = true;
var cardIsValid = true;
CustomerCard card = null;
if (ticketDto.Card == null)
{
hasCard = false;
}
if (hasCard)
{
card = GetCardOrNull(context, ticketDto.Card);
if (card == null)
{
cardIsValid = false;
}
}
if (!cardIsValid)
{
sb.AppendLine("InvalidCard");
continue;
}
var ticket = new Ticket
{
SeatingPlace = ticketDto.Seat,
PersonalCard = card,
Trip = trip,
Price = ticketDto.Price,
};
if (!ValidateEntity.IsValidSeat(context, ticket))
{
sb.AppendLine("InvalidSeat!!!");
continue;
}
validTickets.Add(ticket);
sb.AppendLine($"Ticket from {ticket.Trip.OriginStation.Name} to {ticket.Trip.DestinationStation.Name} Sever departing at {ticket.Trip.DepartureTime.ToString("dd/MM/yyyy HH:mm")} imported.");
}
context.Tickets.AddRange(validTickets);
context.SaveChanges();
return(sb.ToString().TrimEnd('\r', '\n'));
}
private static SeatingClass isSeatExist(TravellingContext context, ClassForTrainDto seatsToCheck, List <SeatingClass> seats)
{
return(seats.FirstOrDefault(s => s.Name == seatsToCheck.Name && s.Abbreviation == seatsToCheck.Abbreviation));
}
public static string ImportTrains(TravellingContext context)
{
var trainsPath = "../../../../resourses/trains.json";
var trainsReader = new StreamReader(trainsPath);
var sb = new StringBuilder();
var trainsToCheck = JsonConvert.DeserializeObject <TrainDto[]>(trainsReader.ReadToEnd(), new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}
)
.ToHashSet <TrainDto>(new TrainComparer());
var seats = context.SeatingClasses.ToList();
var trains = new List <Train>();
var trainSeatsToAdd = new List <TrainSeats>();
foreach (var trainToCheck in trainsToCheck)
{
var IsSeatsValid = true;
if (trainToCheck.TrainNumber == null)
{
continue;
}
if (!ValidateEntity.IsValid(trainToCheck))
{
sb.AppendLine("InvalidTrain");
continue;
}
var seatsToAdd = new List <TrainSeats>();
if (trainToCheck.Seats != null)
{
foreach (var seatsToCheck in trainToCheck.Seats)
{
if (!ValidateEntity.IsValid(seatsToCheck))
{
sb.AppendLine("InvalidSeats");
IsSeatsValid = false;
continue;
}
var currentSeat = isSeatExist(context, seatsToCheck, seats);
if (currentSeat == null)
{
sb.AppendLine("InvalidSeats");
IsSeatsValid = false;
continue;
}
if (!seatsToAdd.Any(s => s.SeatingClass.Name == currentSeat.Name))
{
seatsToAdd.Add(new TrainSeats
{
SeatingClass = currentSeat,
SeatingClassId = currentSeat.Id,
Quantity = seatsToCheck.Quantity
});
}
}
if (!IsSeatsValid)
{
continue;
}
}
var check = Enum.TryParse <TrainType>(trainToCheck.Type, out TrainType result);
var train = new Train
{
TrainNumber = trainToCheck.TrainNumber,
};
if (check)
{
train.Type = result;
}
context.Trains.Add(train);
context.SaveChanges();
for (int i = 0; i < seatsToAdd.Count; i++)
{
var seat = seatsToAdd[i];
seat.TrainId = train.Id;
trainSeatsToAdd.Add(seat);
}
trains.Add(train);
sb.AppendLine($"Record {train.TrainNumber} successfully imported.");
}
context.TrainSeatClasses.AddRange(trainSeatsToAdd);
context.SaveChanges();
return(sb.ToString().TrimEnd('\r', '\n'));
}
private static Train GetTrainOrNull(TravellingContext context, string trainNumber)
{
return(context.Trains.FirstOrDefault(t => t.TrainNumber == trainNumber));
}
private static Station GetStationOrNull(TravellingContext context, string stationName)
{
return(context.Stations.FirstOrDefault(s => s.Name == stationName));
}
public static string ImportTrips(TravellingContext context)
{
var tripsPath = "../../../../resourses/trips.json";
var tripsReader = new StreamReader(tripsPath);
var sb = new StringBuilder();
var tripsToCheck = JsonConvert.DeserializeObject <TripDto[]>(tripsReader.ReadToEnd(), new JsonSerializerSettings
{
DateFormatString = "dd/MM/yyyy HH:mm",
NullValueHandling = NullValueHandling.Ignore,
});
var validTrips = new List <Trip>();
foreach (var tripToCheck in tripsToCheck)
{
var train = GetTrainOrNull(context, tripToCheck.Train);
var originStation = GetStationOrNull(context, tripToCheck.OriginStation);
var destinationStation = GetStationOrNull(context, tripToCheck.DestinationStation);
if (!ValidateEntity.IsValid(tripToCheck) ||
train == null ||
originStation == null ||
destinationStation == null)
{
sb.AppendLine("Invalid data format.");
continue;
}
if (!ValidateEntity.DateTimeValidation(tripToCheck.ArrivalTime.Value, tripToCheck.DepartureTime.Value))
{
sb.AppendLine("Invalid data format.");
continue;
}
var trip = new Trip
{
ArrivalTime = tripToCheck.ArrivalTime.Value,
DepartureTime = tripToCheck.DepartureTime.Value,
Train = train,
OriginStation = originStation,
DestinationStation = destinationStation,
TimeDifference = tripToCheck.TimeDifference,
Status = tripToCheck.Status
};
validTrips.Add(trip);
sb.AppendLine($"Trip from {trip.OriginStation.Name} to {trip.DestinationStation.Name} imported.");
}
context.Trips.AddRange(validTrips);
context.SaveChanges();
return(sb.ToString().TrimEnd('\n', '\r'));
}
private static CustomerCard GetCardOrNull(TravellingContext context, CardForTicketDto card)
{
return(context.CustomerCards.SingleOrDefault(c => c.Name == card.Name));
}
