public static string ImportClasses(StationsDbContext context, string jsonString)
{
var json = JsonConvert.DeserializeObject <List <SeatingClassDto> >(jsonString);
var sb = new StringBuilder();
foreach (var element in json)
{
string name = element.Name;
string abbreviation = element.Abbreviation;
bool isValid = IsValid(element);
if (!isValid || context.SeatingClasses.Any(s => s.Name == name) ||
context.SeatingClasses.Any(s => s.Abbreviation == abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
var seatClass = new SeatingClass()
{
Name = name, Abbreviation = abbreviation
};
context.SeatingClasses.Add(seatClass);
context.SaveChanges();
var msg = string.Format(SuccessMessage, name);
sb.AppendLine(msg);
}
return(sb.ToString());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
SeatingClassDto[] classDtos = JsonConvert.DeserializeObject <SeatingClassDto[]>(jsonString);
List <SeatingClass> seatingClasses = new List <SeatingClass>();
StringBuilder sb = new StringBuilder();
foreach (SeatingClassDto dto in classDtos)
{
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (seatingClasses.Any(sc => sc.Name == dto.Name) || seatingClasses.Any(sc => sc.Abbreviation == dto.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
SeatingClass seatingClass = Mapper.Map <SeatingClass>(dto);
seatingClasses.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, seatingClass.Name));
}
context.SeatingClasses.AddRange(seatingClasses);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
var deserializedClasses = JsonConvert.DeserializeObject <SeatingClass[]>(jsonString);
List <SeatingClass> classes = new List <SeatingClass>();
foreach (var clas in deserializedClasses)
{
if (!IsValid(clas))
{
sb.AppendLine(FailureMessage);
continue;
}
var seatingClassAlreadyExists = classes
.Any(sc => sc.Name == clas.Name || sc.Abbreviation == clas.Abbreviation);
if (seatingClassAlreadyExists)
{
sb.AppendLine(FailureMessage);
continue;
}
var seatClass = new SeatingClass()
{
Name = clas.Name,
Abbreviation = clas.Abbreviation
};
classes.Add(seatClass);
sb.AppendLine(String.Format(SuccessMessage, seatClass.Name));
}
context.SeatingClasses.AddRange(classes);
context.SaveChanges();
return(sb.ToString());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
SeatingClassDto[] deserializedClasses = JsonConvert.DeserializeObject <SeatingClassDto[]>(jsonString);
List <SeatingClass> validClasses = new List <SeatingClass>();
foreach (SeatingClassDto seatingClassDto in deserializedClasses)
{
if (!IsValid(seatingClassDto))
{
sb.AppendLine(FailureMessage);
continue;
}
Boolean classAlreadyExist = validClasses.Any(c => c.Name == seatingClassDto.Name ||
c.Abbreviation == seatingClassDto.Abbreviation);
if (classAlreadyExist)
{
sb.AppendLine(FailureMessage);
continue;
}
SeatingClass seatingClass = Mapper.Map <SeatingClass>(seatingClassDto);
validClasses.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, seatingClassDto.Name));
}
context.SeatingClasses.AddRange(validClasses);
context.SaveChanges();
string result = sb.ToString();
return(result);
}
public void returns_expected_result_when_argument_is_not_empty(string value, SeatingClass expectedResult)
{
var parser = BuildParser();
var result = parser.ParseProperty(value);
Assert.AreEqual(expectedResult, result);
}
public void returns_expected_result_when_argument_is_not_empty(string value, SeatingClass expectedResult)
{
var parser = BuildParser();
var result = parser.ParseProperty(value);
Assert.AreEqual(expectedResult, result);
}
public static void AddTickets(List <TicketImportDto> ticketDtos)
{
using (var context = new StationsContext())
{
foreach (var ticketDto in ticketDtos)
{
// Validate input
Trip trip = context.Trips
.FirstOrDefault(t =>
t.OriginStation.Name == ticketDto.OriginStation &&
t.DestinationStation.Name == ticketDto.DestinationStation &&
t.DepartureTime == ticketDto.DepartureTime);
CustomerCard card = context.CustomerCards
.FirstOrDefault(c => c.Name == ticketDto.CardName);
SeatingClass seatingClass = context.SeatingClasses
.FirstOrDefault(c => c.Abbreviation == ticketDto.Seat.Substring(0, 2));
if (trip == null || card == null || seatingClass == null)
{
Console.WriteLine("Invalid data format.");
continue;
}
// Validate train seats
var trainSeats = context.TrainSeats
.FirstOrDefault(ts => ts.TrainId == trip.TrainId && ts.SeatingClassId == seatingClass.Id);
if (trainSeats == null)
{
Console.WriteLine("Invalid data format.");
continue;
}
// Validate seat number
int seatNumber = int.Parse(ticketDto.Seat.Substring(2));
if (seatNumber < 0 || seatNumber > trainSeats.Quantity)
{
Console.WriteLine("Invalid data format.");
continue;
}
// Add ticket to DB
Ticket ticket = new Ticket
{
TripId = trip.Id,
Price = ticketDto.Price,
SeatingPlace = ticketDto.Seat,
PersonalCardId = card.Id
};
context.Tickets.Add(ticket);
context.SaveChanges();
// Success Notification
Console.WriteLine($"Ticket from {ticketDto.OriginStation} to {ticketDto.DestinationStation} departing at {ticketDto.DepartureTime} imported.");
}
}
}
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 ImportClasses(StationsDbContext context, string jsonString)
{
var classesDto = JsonConvert.DeserializeObject <ClassDto[]>(jsonString);
var sb = new StringBuilder();
var existingNames = context.SeatingClasses.Select(x => x.Name).ToList();
var existingAbb = context.SeatingClasses.Select(x => x.Abbreviation).ToList();
var classes = new List <SeatingClass>();
foreach (var dto in classesDto)
{
if (existingNames.Contains(dto.Name) || existingAbb.Contains(dto.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
existingAbb.Add(dto.Abbreviation);
existingNames.Add(dto.Name);
var @class = new SeatingClass()
{
Name = dto.Name,
Abbreviation = dto.Abbreviation
};
classes.Add(@class);
sb.AppendLine(string.Format(SuccessMessage, @class.Name));
}
context.SeatingClasses.AddRange(classes);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var sb = new StringBuilder();
var serializer = JsonConvert.DeserializeObject <List <ImportSeatingClassDto> >(jsonString);
var seatingClassesToAdd = new List <SeatingClass>();
foreach (var seatingClassDto in serializer)
{
if (!IsValid(seatingClassDto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (seatingClassesToAdd.Any(sc => sc.Name == seatingClassDto.Name) ||
seatingClassesToAdd.Any(sc => sc.Abbreviation == seatingClassDto.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
var seatingClass = new SeatingClass()
{
Abbreviation = seatingClassDto.Abbreviation,
Name = seatingClassDto.Name
};
seatingClassesToAdd.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, seatingClass.Name));
}
context.SeatingClasses.AddRange(seatingClassesToAdd);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var deserializedClasses = JsonConvert.DeserializeObject <SeatingClassDto[]>(jsonString);
var validClasses = new List <SeatingClass>();
var sb = new StringBuilder();
foreach (var classDto in deserializedClasses)
{
if (!IsValid(classDto))
{
sb.AppendLine(FailureMessage);
continue;
}
bool seatingClassExists = validClasses.Any(a => a.Name == classDto.Name || a.Abbreviation == classDto.Abbreviation);
if (seatingClassExists)
{
sb.AppendLine(FailureMessage);
continue;
}
SeatingClass seatingClass = new SeatingClass
{
Name = classDto.Name,
Abbreviation = classDto.Abbreviation,
};
validClasses.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, seatingClass.Name));
}
context.SeatingClasses.AddRange(validClasses);
context.SaveChanges();
string result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var classesDto = JsonConvert.DeserializeObject <ImportClassesDto[]>(jsonString);
var classes = new List <SeatingClass>();
var sb = new StringBuilder();
foreach (var classDto in classesDto)
{
if (classes.Any(x => x.Name == classDto.Name) ||
classes.Any(x => x.Abbreviation == classDto.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
if (!IsValid(classDto))
{
sb.AppendLine(FailureMessage);
continue;
}
var importClass = new SeatingClass
{
Name = classDto.Name,
Abbreviation = classDto.Abbreviation
};
classes.Add(importClass);
sb.AppendLine(String.Format(SuccessMessage, importClass.Name));
}
context.SeatingClasses.AddRange(classes);
context.SaveChanges();
string result = sb.ToString().TrimEnd();
return(result);
}
public SeatingClass GetOrAddSeatingClass(SeatingClass seatingClass, out bool isImported)
{
SeatingClass seat = this.context.SeatingClasses.SingleOrDefault(sc => sc.Name == seatingClass.Name);
isImported = false;
if (seat == null)
{
seat = seatingClass;
isImported = true;
if (!this.IsEntityValid(seat))
{
throw new InvalidOperationException("Seat is not valid!");
}
this.context.SeatingClasses.Add(seat);
this.context.SaveChanges();
}
return(seat);
}
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 ImportClasses(StationsDbContext context, string jsonString)
{
var seatedClassesDeserialize = JsonConvert.DeserializeObject <SeatingClassDto[]>(jsonString);
StringBuilder sb = new StringBuilder();
var seatedClasses = new List <SeatingClass>();
foreach (var seatClassDto in seatedClassesDeserialize)
{
if (string.IsNullOrWhiteSpace(seatClassDto.Name) ||
string.IsNullOrWhiteSpace(seatClassDto.Abbreviation) ||
seatClassDto.Name.Length > 30 || seatClassDto.Abbreviation.Length != 2)
{
sb.AppendLine(FailureMessage);
continue;
}
if (seatedClasses.Any(x => x.Name == seatClassDto.Name) ||
seatedClasses.Any(x => x.Abbreviation == seatClassDto.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
SeatingClass seatingClass = new SeatingClass()
{
Name = seatClassDto.Name,
Abbreviation = seatClassDto.Abbreviation
};
seatedClasses.Add(seatingClass);
sb.AppendLine(String.Format(SuccessMessage, seatClassDto.Name));
}
context.SeatingClasses.AddRange(seatedClasses);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var seatingClasses = JsonConvert.DeserializeObject <SeatingClassDto[]>(jsonString);
var sb = new StringBuilder();
var validSeatingClasses = new List <SeatingClass>();
foreach (var dto in seatingClasses)
{
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (validSeatingClasses.Any(sc => sc.Name == dto.Name || sc.Abbreviation == dto.Abbreviation))
{
sb.AppendLine(FailureMessage);
continue;
}
var seatingClass = new SeatingClass()
{
Name = dto.Name,
Abbreviation = dto.Abbreviation
};
validSeatingClasses.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, dto.Name));
}
context.SeatingClasses.AddRange(validSeatingClasses);
context.SaveChanges();
var result = sb.ToString().Trim();
return(result);
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var dtos = JsonConvert.DeserializeObject <SeatingClassImportDto[]>(jsonString);
var sb = new StringBuilder();
var classes = new List <SeatingClass>();
foreach (var dto in dtos)
{
if (!IsValid(dto) ||
classes.Any(c =>
c.Name.Equals(dto.Name, StringComparison.OrdinalIgnoreCase) ||
c.Abbreviation.Equals(dto.Abbreviation, StringComparison.OrdinalIgnoreCase)
))
{
sb.AppendLine(FailureMessage);
continue;
}
var seatingClass = new SeatingClass
{
Name = dto.Name,
Abbreviation = dto.Abbreviation
};
classes.Add(seatingClass);
sb.AppendLine(String.Format(SuccessMessage, seatingClass.Name));
}
context.SeatingClasses.AddRange(classes);
context.SaveChanges();
var result = sb.ToString();
return(result);
}
public static string ImportClasses(StationsDbContext context, string jsonString)
{
var sb = new StringBuilder();
var deserializeSeatingClasses = JsonConvert.DeserializeObject <SeatingClassesDto[]>(jsonString);
foreach (var dto in deserializeSeatingClasses)
{
if (dto.Name == null || dto.Abbreviation == null || dto.Name.Length > 30 || dto.Abbreviation.Length < 2 || dto.Abbreviation.Length > 2)
{
sb.AppendLine(FailureMessage);
continue;
}
var isNameExists = context.SeatingClasses.Any(sc => sc.Name == dto.Name);
var isAbrExists = context.SeatingClasses.Any(sc => sc.Abbreviation == dto.Abbreviation);
if (isNameExists || isAbrExists)
{
sb.AppendLine(FailureMessage);
continue;
}
var newSeatingClasses = new SeatingClass()
{
Name = dto.Name,
Abbreviation = dto.Abbreviation
};
context.SeatingClasses.Add(newSeatingClasses);
context.SaveChanges();
sb.AppendLine(String.Format(SuccessMessage, dto.Name));
}
var result = sb.ToString().Trim();
return(result);
}
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 ImportClasses(StationsDbContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
ImportSeatingClassDto[] classDtos = JsonConvert.DeserializeObject <ImportSeatingClassDto[]>(jsonString);
List <SeatingClass> seatingClassesToAdd = new List <SeatingClass>();
foreach (var classDto in classDtos)
{
if (!IsValid(classDto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (seatingClassesToAdd.Any(x => x.Abbreviation.Equals(classDto.Abbreviation)) || seatingClassesToAdd.Any(x => x.Name == classDto.Name))
{
sb.AppendLine(FailureMessage);
continue;
}
SeatingClass seatingClass = new SeatingClass()
{
Name = classDto.Name,
Abbreviation = classDto.Abbreviation
};
seatingClassesToAdd.Add(seatingClass);
sb.AppendLine(string.Format(SuccessMessage, seatingClass.Name));
}
context.SeatingClasses.AddRange(seatingClassesToAdd);
context.SaveChanges();
return(sb.ToString().Trim());
}
private static bool IsValidClassManual(SeatingClass seatingClass, StationsDbContext context)
{
if (seatingClass.Name == null)
{
return(false);
}
if (seatingClass.Abbreviation == null)
{
return(false);
}
if (seatingClass.Abbreviation.Length != 2)
{
return(false);
}
if (seatingClass.Name.Length > 30)
{
return(false);
}
if (context.SeatingClasses.Any(s => s.Name == seatingClass.Name))
{
return(false);
}
return(true);
}
