private static void ImportAnomalyVictims()
{
MassDefectContext context = new MassDefectContext();
string json = File.ReadAllText(Constants.AnomalyVictimsPath);
IEnumerable <AnomalyVictimDTO> anomalyVictims = JsonConvert.DeserializeObject <IEnumerable <AnomalyVictimDTO> >(json);
foreach (AnomalyVictimDTO anomalyVictim in anomalyVictims)
{
if (anomalyVictim.Id == null || anomalyVictim.Person == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
Anomaly anomaly = context.Anomalies.SingleOrDefault(a => a.Id == anomalyVictim.Id);
Person person = context.People.SingleOrDefault(p => p.Name == anomalyVictim.Person);
if (anomaly == null || person == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
anomaly.Victims.Add(person);
context.SaveChanges();
}
}
private static void ImportSolarSystems()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(SolarSystemsPath);
var solarSystems = JsonConvert.DeserializeObject <IEnumerable <SolarSystemDTO> >(json);
foreach (var solarSystem in solarSystems)
{
if (solarSystem.Name == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var solarSystemEntity = new SolarSystem()
{
Name = solarSystem.Name
};
context.SolarSystems.Add(solarSystemEntity);
context.SaveChanges();
Console.WriteLine($"Successfully imported SolarSystem {solarSystemEntity.Name}.");
}
}
private static void ImportAnomalies()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(AnomaliesPath);
var anomalies = JsonConvert.DeserializeObject <IEnumerable <AnomalyDTO> >(json);
foreach (var anomaly in anomalies)
{
if ((context.Planets.Where(n => n.Name == anomaly.OriginPlanet).Count() == 0) ||
(context.Planets.Where(n => n.Name == anomaly.TeleportPlanet).Count() == 0))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var anomalyEntity = new Anomaly()
{
OriginPlanet = GetPlanetByName(anomaly.OriginPlanet, context),
TeleportPlanet = GetPlanetByName(anomaly.TeleportPlanet, context)
};
context.Anomalies.Add(anomalyEntity);
context.SaveChanges();
Console.WriteLine($"Successfully imported anomaly.");
}
}
public static void Planets()
{
using (MassDefectContext context = new MassDefectContext())
{
string json = File.ReadAllText(PlanetsPath);
IEnumerable <PlanetDTO> planetsDtos = JsonConvert.DeserializeObject <IEnumerable <PlanetDTO> >(json);
foreach (PlanetDTO planetDto in planetsDtos)
{
if (planetDto.Name == null || planetDto.Sun == null || planetDto.SolarSystem == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
Planet planetEntity = new Planet()
{
Name = planetDto.Name,
Sun = GetStarByName(planetDto.Sun, context),
SolarSystem = GetSolarSystemByName(planetDto.SolarSystem, context)
};
if (planetEntity.Sun == null || planetEntity.SolarSystem == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
context.Planets.Add(planetEntity);
Console.WriteLine(Constants.ImportNamedEntitySuccessMessage, "Planet", planetEntity.Name);
}
context.SaveChanges();
}
}
private static void ImportPlanets()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(PlanetsPath);
var planets = JsonConvert.DeserializeObject <IEnumerable <PlanetDTO> >(json);
foreach (var planet in planets)
{
if ((planet.Name == null) || (context.Stars.Where(n => n.Name == planet.Sun).Count() == 0) || (context.SolarSystems.Where(n => n.Name == planet.SolarSystem).Count() == 0))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var PlanetEntity = new Planet()
{
Name = planet.Name,
Sun = GetSunByName(planet.Sun, context),
SolarSystem = GetSolarSystemByName(planet.SolarSystem, context)
};
context.Planets.Add(PlanetEntity);
context.SaveChanges();
Console.WriteLine($"Successfully imported Planet {PlanetEntity.Name}.");
}
}
public static void Anomalies()
{
using (MassDefectContext context = new MassDefectContext())
{
string json = File.ReadAllText(AnomaliesPath);
IEnumerable <AnomalyDTO> anomaliesDtos = JsonConvert.DeserializeObject <IEnumerable <AnomalyDTO> >(json);
foreach (AnomalyDTO anomalyDto in anomaliesDtos)
{
if (anomalyDto.OriginPlanet == null || anomalyDto.TeleportPlanet == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
Anomaly anomalyEntity = new Anomaly()
{
OriginPlanet = GetPlanetByName(anomalyDto.OriginPlanet, context),
TeleportPlanet = GetPlanetByName(anomalyDto.TeleportPlanet, context)
};
if (anomalyEntity.OriginPlanet == null || anomalyEntity.TeleportPlanet == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
context.Anomalies.Add(anomalyEntity);
Console.WriteLine(Constants.ImportUnnamedEntitySuccessMessage);
}
context.SaveChanges();
}
}
public static void SolarSystems()
{
using (MassDefectContext context = new MassDefectContext())
{
string json = File.ReadAllText(SolarSystemPath);
IEnumerable <SolarSystemDTO> solarSystemsDtos = JsonConvert.DeserializeObject <IEnumerable <SolarSystemDTO> >(json);
foreach (SolarSystemDTO solarSystemDto in solarSystemsDtos)
{
if (solarSystemDto.Name == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
SolarSystem solarSystemEntity = new SolarSystem()
{
Name = solarSystemDto.Name
};
context.SolarSystems.Add(solarSystemEntity);
Console.WriteLine(Constants.ImportNamedEntitySuccessMessage, "Solar System", solarSystemEntity.Name);
}
context.SaveChanges();
}
}
private static void ImportStars()
{
var context = new MassDefectContext();
var json = File.ReadAllText(StarsPath);
var stars = JsonConvert.DeserializeObject <IEnumerable <StarDTO> >(json);
foreach (var star in stars)
{
if (star.Name == null || star.SolarSystem == null)
{
RaiseError();
continue;
}
var starEntity = new Stars
{
Name = star.Name,
SolarSystem = GetSolarSystemByName(star.SolarSystem, context)
};
if (starEntity.SolarSystem == null)
{
RaiseError();
continue;
}
context.Stars.Add(starEntity);
Console.WriteLine($"Successfully imported Star {starEntity.Name}.");
}
context.SaveChanges();
}
private static void ImportAnomalies()
{
var context = new MassDefectContext();
var json = File.ReadAllText(AnomaliesPath);
var anomalies = JsonConvert.DeserializeObject <IEnumerable <AnomaliesDTO> >(json);
foreach (var anomaly in anomalies)
{
if (anomaly.OriginPlanet == null || anomaly.TeleportPlanet == null)
{
RaiseError();
continue;
}
var anomalyEntity = new Anomalies
{
OriginPlanet = GetOriginPlanet(anomaly.OriginPlanet, context),
TeleportPlanet = GetTeleportPlanet(anomaly.TeleportPlanet, context)
};
if (anomalyEntity.TeleportPlanet == null || anomalyEntity.OriginPlanet == null)
{
RaiseError();
continue;
}
context.Anomalies.Add(anomalyEntity);
Console.WriteLine($"Successfully imported anomaly.");
}
context.SaveChanges();
}
static void Main()
{
var xml = XDocument.Load(NEW_ANOMALIES_ROUTE);
var anomalies = xml.XPathSelectElements("anomalies/anomaly");
var context = new MassDefectContext();
foreach (var anomaly in anomalies)
{
ImportAnomalyAndVictims(anomaly, context);
}
try
{
context.SaveChanges();
}
catch (DbEntityValidationException ex)
{
foreach (var ms in ex.EntityValidationErrors)
{
foreach (var m in ms.ValidationErrors)
{
Console.WriteLine(m.ErrorMessage);
}
}
}
}
private static void ImportPlanets()
{
var context = new MassDefectContext();
var json = File.ReadAllText(PlanetsPath);
var planets = JsonConvert.DeserializeObject <IEnumerable <PlanetsDTO> >(json);
foreach (var planet in planets)
{
if (planet.Name == null || planet.SolarSystem == null || planet.Sun == null)
{
RaiseError();
continue;
}
var planetEntity = new Planets
{
Name = planet.Name,
SolarSystem = GetSolarSystemByName(planet.SolarSystem, context),
Sun = GetSunByName(planet.Sun, context)
};
if (planetEntity.Name == null || planetEntity.Sun == null || planetEntity.SolarSystem == null)
{
RaiseError();
continue;
}
context.Planets.Add(planetEntity);
Console.WriteLine($"Successfully imported Planet {planetEntity.Name}.");
}
context.SaveChanges();
}
public static void ImportAnomalyVictims()
{
var context = new MassDefectContext();
var json = File.ReadAllText(Paths.AnomalyVictimsPath);
var anomalyVictims = JsonConvert.DeserializeObject <IEnumerable <AnomalyVictimsDTO> >(json);
foreach (var anomalyVictim in anomalyVictims)
{
if (anomalyVictim.Id == null || anomalyVictim.Person == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
int anomalyId = int.Parse(anomalyVictim.Id);
if (!context.Anomalies.Any(a => a.Id == anomalyId) ||
!context.People.Any(p => p.Name == anomalyVictim.Person))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var personEntity = context.People
.First(p => p.Name == anomalyVictim.Person);
var anomalyEntity = context.Anomalies.Find(anomalyId);
personEntity.Anomalies.Add(anomalyEntity);
}
context.SaveChanges();
}
private static void ImportPlanets()
{
MassDefectContext context = new MassDefectContext();
string json = File.ReadAllText(Constants.PlanetsPath);
IEnumerable <PlanetDTO> planets = JsonConvert.DeserializeObject <IEnumerable <PlanetDTO> >(json);
foreach (PlanetDTO planet in planets)
{
if (planet.Name == null || planet.SolarSystem == null || planet.Sun == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
SolarSystem solarySystem = context.SolarSystems.SingleOrDefault(s => s.Name == planet.SolarSystem);
Star star = context.Stars.SingleOrDefault(s => s.Name == planet.Sun);
if (solarySystem == null || star == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
Planet planetEntity = new Planet(planet.Name, star, solarySystem);
context.Planets.Add(planetEntity);
context.SaveChanges();
Console.WriteLine(Constants.SuccessMessage, "Planet", planet.Name);
}
}
private static void ImportStars()
{
MassDefectContext context = new MassDefectContext();
string json = File.ReadAllText(Constants.StarsPath);
IEnumerable <StarDTO> stars = JsonConvert.DeserializeObject <IEnumerable <StarDTO> >(json);
foreach (StarDTO star in stars)
{
if (star.Name == null || star.SolarSystem == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
SolarSystem solarSystem = context.SolarSystems.SingleOrDefault(s => s.Name == star.SolarSystem);
if (solarSystem == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
Star starEntity = new Star(star.Name, solarSystem);
context.Stars.Add(starEntity);
context.SaveChanges();
Console.WriteLine(Constants.SuccessMessage, "Star", star.Name);
}
}
private static void ImportPersons()
{
var context = new MassDefectContext();
var json = File.ReadAllText(PersonsPath);
var persons = JsonConvert.DeserializeObject <IEnumerable <PersonDto> >(json);
foreach (var person in persons)
{
if (person.Name == null || person.HomePlanet == null)
{
//throw new ArgumentNullException("Error: Invalid data.”… ");
Console.WriteLine("Error: Invalid data.");
continue;
}
var personEntity = new Person
{
Name = person.Name,
HomePlanet = GetPlanetByNameOfPlanet(person.HomePlanet, context)
};
if (personEntity.HomePlanet == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
context.Persons.Add(personEntity);
Console.WriteLine($"Successfully imported Person {person.Name}.");
}
context.SaveChanges();
}
private static void ImportPersons()
{
var context = new MassDefectContext();
var json = File.ReadAllText(PersonsPath);
var persons = JsonConvert.DeserializeObject <IEnumerable <PersonsDTO> >(json);
foreach (var person in persons)
{
if (person.Name == null || person.HomePlanet == null)
{
RaiseError();
continue;
}
var personEntity = new Person
{
Name = person.Name,
HomePlanet = GetPlanetByName(person.HomePlanet, context),
};
if (personEntity.Name == null || personEntity.HomePlanet == null)
{
RaiseError();
continue;
}
context.Persons.Add(personEntity);
Console.WriteLine($"Successfully imported Person {personEntity.Name}.");
}
context.SaveChanges();
}
public static void Persons()
{
using (MassDefectContext context = new MassDefectContext())
{
string json = File.ReadAllText(PersonsPath);
IEnumerable <PersonDTO> personsDtos = JsonConvert.DeserializeObject <IEnumerable <PersonDTO> >(json);
foreach (PersonDTO personDto in personsDtos)
{
if (personDto.Name == null || personDto.HomePlanet == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
Person personEntity = new Person()
{
Name = personDto.Name,
HomePlanet = GetPlanetByName(personDto.HomePlanet, context)
};
if (personEntity.HomePlanet == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
context.People.Add(personEntity);
Console.WriteLine(Constants.ImportNamedEntitySuccessMessage, "Person", personEntity.Name);
}
context.SaveChanges();
}
}
private static void ImportAnomalyAndVictims(XElement anomalyNode, MassDefectContext context)
{
var originPlanetName = anomalyNode.Attribute("origin-planet");
var teleportPlanetName = anomalyNode.Attribute("teleport-planet");
if ((context.Planets.Where(n => n.Name == originPlanetName.Value).Count() > 0) &&
(context.Planets.Where(n => n.Name == teleportPlanetName.Value).Count() > 0) &&
(originPlanetName.Value != null) &&
(teleportPlanetName.Value != null))
{
var anomalyEntity = new Anomaly()
{
OriginPlanet = GetPlanetByName(originPlanetName.Value, context),
TeleportPlanet = GetPlanetByName(teleportPlanetName.Value, context)
};
context.Anomalies.Add(anomalyEntity);
var victims = anomalyNode.XPathSelectElements("victims/victim");
foreach (var victim in victims)
{
ImportVictim(victim, context, anomalyEntity);
}
context.SaveChanges();
Console.WriteLine("Successfully imported anomaly and victims.");
}
else
{
Console.WriteLine("Error: Invalid data.");
}
}
public static void AnomalyVictims()
{
using (MassDefectContext context = new MassDefectContext())
{
string json = File.ReadAllText(AnomalyVictimsPath);
IEnumerable <AnomalyVictimsDTO> anomalyVictimsDtos = JsonConvert.DeserializeObject <IEnumerable <AnomalyVictimsDTO> >(json);
foreach (var anomalyVictimDto in anomalyVictimsDtos)
{
if (anomalyVictimDto.Id == null || anomalyVictimDto.Person == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
Anomaly anomalyEntity = GetAnomalyById(anomalyVictimDto.Id, context);
Person personEntity = GetPersonByName(anomalyVictimDto.Person, context);
if (anomalyEntity == null || personEntity == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
anomalyEntity.Victims.Add(personEntity);
}
context.SaveChanges();
}
}
private static void ImportAnomalyAndVictims(XElement anomalyNode, MassDefectContext context)
{
var originPlanetName = anomalyNode.Attribute("origin-planet");
var teleportPlanetName = anomalyNode.Attribute("teleport-planet");
if (originPlanetName == null || teleportPlanetName == null)
{
Console.WriteLine("Error: Invalid data.");
return;
}
var anomalyEntity = new Anomaly
{
OriginPlanet = GetPlanetByName(originPlanetName.Value, context),
TeleportPlanet = GetPlanetByName(teleportPlanetName.Value, context)
};
if (anomalyEntity.OriginPlanet == null || anomalyEntity.TeleportPlanet == null)
{
Console.WriteLine("Error: Invalid data.");
return;
}
context.Anomalies.Add(anomalyEntity);
Console.WriteLine("Successfully imported anomaly.");
var victims = anomalyNode.XPathSelectElements("victims/victim");
foreach (var victim in victims)
{
ImportVictim(victim, context, anomalyEntity);
}
context.SaveChanges();
}
public static void Stars()
{
using (MassDefectContext context = new MassDefectContext())
{
string json = File.ReadAllText(StarsPath);
IEnumerable <StarDTO> starsDtos = JsonConvert.DeserializeObject <IEnumerable <StarDTO> >(json);
foreach (StarDTO starDto in starsDtos)
{
if (starDto.Name == null || starDto.SolarSystem == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
Star starEntity = new Star()
{
Name = starDto.Name,
SolarSystem = GetSolarSystemByName(starDto.SolarSystem, context)
};
if (starEntity.SolarSystem == null)
{
Console.WriteLine(Constants.ImportErrorMessage);
continue;
}
context.Stars.Add(starEntity);
Console.WriteLine(Constants.ImportNamedEntitySuccessMessage, "Star", starEntity.Name);
}
context.SaveChanges();
}
}
private static void ImportPlanets()
{
var context = new MassDefectContext();
var json = File.ReadAllText(PlanetsPath);
var planets = JsonConvert.DeserializeObject <IEnumerable <PlanetDto> >(json);
foreach (var planet in planets)
{
if (planet.Name == null || planet.SolarSystem == null || planet.Sun == null)
{
//throw new ArgumentNullException("Error: Invalid data.”… ");
Console.WriteLine("Error: Invalid data.");
continue;
}
var planetEntity = new Planet
{
Name = planet.Name,
SolarSystem = GetSolarSystemsByName(planet.SolarSystem, context),
Sun = GetSunByNameOfStar(planet.Sun, context)
};
if (planetEntity.Sun == null || planetEntity.SolarSystem == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
context.Planets.Add(planetEntity);
Console.WriteLine($"Successfully imported Planet {planet.Name}.");
}
context.SaveChanges();
}
private static void ImportAnomalyAndVictims(XElement anomalieNode, MassDefectContext context)
{
var teleportPlanet = anomalieNode.Attribute("teleport-planet");
var originPlanet = anomalieNode.Attribute("origin-planet");
if (teleportPlanet == null || originPlanet == null)
{
Console.WriteLine(ErrorMessage);
return;
}
Anomaly anomalyEntity = new Anomaly()
{
OriginPlanet = GetPlanetByName(originPlanet.Value, context),
TeleportPlanet = GetPlanetByName(teleportPlanet.Value, context)
};
if (anomalyEntity.OriginPlanet == null || anomalyEntity.TeleportPlanet == null)
{
Console.WriteLine(ErrorMessage);
return;
}
context.Anomalies.Add(anomalyEntity);
Console.WriteLine(SuccessfullMessage);
IEnumerable <XElement> victims = anomalieNode.XPathSelectElements("victims/victims");
foreach (XElement victim in victims)
{
ImportVictim(victim, context, anomalyEntity);
}
context.SaveChanges();
}
private static void ImportStars()
{
var context = new MassDefectContext();
var json = File.ReadAllText(StarsPath);
var stars = JsonConvert.DeserializeObject <IEnumerable <StarDto> >(json);
foreach (var star in stars)
{
//
if (star.Name == null || star.SolarSystem == null)
{
//throw new ArgumentNullException("Error: Invalid data.”… ");
Console.WriteLine("Error: Invalid data.");
continue;
}
var starEntity = new Star
{
Name = star.Name,
SolarSystem = GetSolarSystemsByName(star.SolarSystem, context)
};
if (starEntity.SolarSystem == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
context.Stars.Add(starEntity);
Console.WriteLine($"Successfully imported Star {star.Name}.");
}
context.SaveChanges();
}
private static void ImportStars()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(StarsPath);
var stars = JsonConvert.DeserializeObject <IEnumerable <StarDTO> >(json);
foreach (var star in stars)
{
if ((star.Name == null) || (star.SolarSystem == null) || (context.SolarSystems.Where(n => n.Name == star.SolarSystem).Count() == 0))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var StarEntity = new Star()
{
Name = star.Name,
SolarSystem = GetSolarSystemByName(star.SolarSystem, context)
};
context.Stars.Add(StarEntity);
context.SaveChanges();
Console.WriteLine($"Successfully imported Star {StarEntity.Name}.");
}
}
private static void ImportAnomalyVictims()
{
var context = new MassDefectContext();
var json = File.ReadAllText(AnomalyVictimsPath);
var anomalyVictims = JsonConvert.DeserializeObject <IEnumerable <AnomalyVictimsDto> >(json);
foreach (var anomalyVictim in anomalyVictims)
{
if (anomalyVictim.Id == null || anomalyVictim.Person == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var anomalyEntity = GetAnomalyById(anomalyVictim.Id, context);
var personEntity = GetPersonByName(anomalyVictim.Person, context);
if (anomalyEntity == null || personEntity == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
anomalyEntity.Victims.Add(personEntity);
}
context.SaveChanges();
}
private static void ImportAnomalyVictims()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(AnomalyVictimsPath);
var anomalyVictims = JsonConvert.DeserializeObject <IEnumerable <AnomalyVictimsDTO> >(json);
foreach (var anomalyVictim in anomalyVictims)
{
if ((anomalyVictim.Id.ToString() == null) ||
(anomalyVictim.Person == null))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
if ((context.Persons.Where(n => n.Name == anomalyVictim.Person).Count() == 0) ||
(context.Anomalies.Where(i => i.Id == anomalyVictim.Id).Count() == 0))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var anomalyEntity = GetAnomalyById(anomalyVictim.Id, context);
var personEntity = GetPersonByName(anomalyVictim.Person, context);
anomalyEntity.AnomalyVictims.Add(personEntity);
context.SaveChanges();
}
}
private static void ImportAnomalies()
{
var context = new MassDefectContext();
var json = File.ReadAllText(AnomaliesPath);
var anomalies = JsonConvert.DeserializeObject <IEnumerable <AnomalyDto> >(json);
foreach (var anomaly in anomalies)
{
if (anomaly.OriginPlanet == null || anomaly.TeleportPlanet == null)
{
//throw new ArgumentNullException("Error: Invalid data.”… ");
Console.WriteLine("Error: Invalid data.");
continue;
}
var anomalyEntity = new Anomaly
{
OriginPlanet = GetPlanetByNameOfPlanet(anomaly.OriginPlanet, context),
TeleportPlanet = GetPlanetByNameOfPlanet(anomaly.TeleportPlanet, context)
};
if (anomalyEntity.OriginPlanet == null || anomalyEntity.TeleportPlanet == null)
{
Console.WriteLine("Error: Invalid data.");
continue;
}
context.Anomalies.Add(anomalyEntity);
Console.WriteLine($"Successfully imported Anomaly {anomaly.OriginPlanet}.");
}
context.SaveChanges();
}
private static void ImportPersons()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(PersonsPath);
var persons = JsonConvert.DeserializeObject <IEnumerable <PersonDTO> >(json);
foreach (var person in persons)
{
if ((person.Name == null) || (context.Planets.Where(n => n.Name == person.HomePlanet).Count() == 0))
{
Console.WriteLine("Error: Invalid data.");
continue;
}
var PersonEntity = new Person()
{
Name = person.Name,
HomePlanet = GetPlanetByName(person.HomePlanet, context)
};
context.Persons.Add(PersonEntity);
context.SaveChanges();
Console.WriteLine($"Successfully imported Person {PersonEntity.Name}.");
}
}
private static void ImportAnomalies()
{
MassDefectContext context = new MassDefectContext();
var json = File.ReadAllText(Constants.AnomaliesPath);
var anomalies = JsonConvert.DeserializeObject <IEnumerable <AnomalyDTO> >(json);
foreach (AnomalyDTO anomaly in anomalies)
{
if (anomaly.OriginPlanet == null || anomaly.TeleportPlanet == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
Planet originPlanet = context.Planets.SingleOrDefault(p => p.Name == anomaly.OriginPlanet);
Planet teleportPlanet = context.Planets.SingleOrDefault(p => p.Name == anomaly.TeleportPlanet);
if (originPlanet == null || teleportPlanet == null)
{
Console.WriteLine(Constants.ErrorMessage);
continue;
}
Anomaly anomalyEntity = new Anomaly(originPlanet, teleportPlanet);
context.Anomalies.Add(anomalyEntity);
context.SaveChanges();
Console.WriteLine("Successfully imported anomaly.");
}
}
