public static string ExportAllProcedures(PetClinicContext context)
{
var procedure = context.Procedures
.OrderBy(d => d.DateTime)
.Select(p => new ProcedureDto
{
Passport = p.Animal.PassportSerialNumber,
OwnerNumber = p.Animal.Passport.OwnerPhoneNumber,
DateTime = p.DateTime.ToString("dd-MM-yyyy", CultureInfo.InvariantCulture),
AnimalAids = p.ProcedureAnimalAids
.Select(a => new AnimalAidDto
{
Name = a.AnimalAid.Name,
Price = a.AnimalAid.Price
})
.ToList(),
TotalPrice = p.ProcedureAnimalAids
.Sum(a => a.AnimalAid.Price)
})
.OrderBy(p => p.Passport)
.ToList();
var sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(List <ProcedureDto>), new XmlRootAttribute("Procedures"));
var xmlNamespaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
serializer.Serialize(new StringWriter(sb), procedure, xmlNamespaces);
return(sb.ToString().TrimEnd());
}
public static string ExportAllProcedures(PetClinicContext context)
{
var procedures = context.Procedures.OrderBy(x => x.DateTime).ThenBy(x => x.Animal.PassportSerialNumber).Select(x => new ProcedureDto
{
AnimalSerialNumber = x.Animal.PassportSerialNumber,
DateTime = x.DateTime.ToString("dd-MM-yyyy"),
OwnerNumber = x.Animal.Passport.OwnerPhoneNumber,
TotalPrice = x.ProcedureAnimalAids.Sum(e => e.AnimalAid.Price),
AnimalAid = x.ProcedureAnimalAids.Select(p => new AnimalAidDto
{
Name = p.AnimalAid.Name,
Price = p.AnimalAid.Price
}).ToArray()
}).ToArray();
var serializer = new XmlSerializer(typeof(ProcedureDto[]), new XmlRootAttribute("Procedures"));
var xmlNamespaces = new XmlSerializerNamespaces();
xmlNamespaces.Add("", "");
StringBuilder sb = new StringBuilder();
serializer.Serialize(new StringWriter(sb), procedures, xmlNamespaces);
return(sb.ToString().TrimEnd());
}
public static string ExportAllProcedures(PetClinicContext context)
{
var procedures = context.Procedures
.OrderBy(x => x.DateTime)
.ThenBy(x => x.Animal.PassportSerialNumber)
.Select(x => new ExportProceduresDto()
{
Passport = x.Animal.PassportSerialNumber,
OwnerNumber = x.Animal.Passport.OwnerPhoneNumber,
DateTime = x.DateTime.ToString("dd-MM-yyyy", CultureInfo.InvariantCulture),
AnimalAids = x.ProcedureAnimalAids
.Select(pa => new ExportAidsDto
{
Name = pa.AnimalAid.Name,
Price = pa.AnimalAid.Price
})
.ToArray(),
TotalPrice = x.ProcedureAnimalAids.Select(pa => pa.AnimalAid.Price).Sum()
})
.ToArray();
var sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(ExportProceduresDto[]), new XmlRootAttribute("Procedures"));
var namespaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
serializer.Serialize(new StringWriter(sb), procedures, namespaces);
return(sb.ToString());
}
public static string ImportVets(PetClinicContext context, string xmlString)
{
var sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(VetDto[]), new XmlRootAttribute("Vets"));
var deserializeVets = (VetDto[])serializer
.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var validVets = new List <Vet>();
foreach (var vetDto in deserializeVets)
{
var vetIsValid = IsValid(vetDto);
var vetAlreadyExist = validVets.Any(v => v.PhoneNumber == vetDto.PhoneNumber);
if (!vetIsValid || vetAlreadyExist)
{
sb.AppendLine(ErrorMessage);
continue;
}
var vet = Mapper.Map <Vet>(vetDto);
validVets.Add(vet);
sb.AppendLine(string.Format(SuccessfullMessage, vet.Name));
}
context.Vets.AddRange(validVets);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
var animalAids = JsonConvert.DeserializeObject <AnimalAid[]>(jsonString);
var validAids = new List <AnimalAid>();
var sb = new StringBuilder();
foreach (var animalAid in animalAids)
{
var isValid = IsValid(animalAid, out var validationResults);
var isExisting = context.AnimalAids.FirstOrDefault(a => a.Name == animalAid.Name);
if (isValid && isExisting == null)
{
context.AnimalAids.Add(animalAid);
context.SaveChanges();
sb.AppendLine($"Record {animalAid.Name} successfully imported.");
}
else
{
sb.AppendLine(errorMessage);
continue;
}
}
return(sb.ToString().TrimEnd());
}
public static string ImportAnimals(PetClinicContext context, string jsonString)
{
var sb = new StringBuilder();
var deserializedAnimals = JsonConvert.DeserializeObject <AnimalDto[]>(jsonString);
var validAnimals = new List <Animal>();
foreach (var animalDto in deserializedAnimals)
{
// If any validation errors occur do not import the entity
var animalIsValid = IsValid(animalDto);
var passportIsValid = IsValid(animalDto.Passport);
// If a passport with the same serial number exists, do not import the entity
var animalAlreadyExist = validAnimals
.Any(p => p.Passport.SerialNumber == animalDto.Passport.SerialNumber);
if (!animalIsValid || !passportIsValid || animalAlreadyExist)
{
sb.AppendLine(ErrorMessage);
continue;
}
var animal = Mapper.Map <Animal>(animalDto);
validAnimals.Add(animal);
sb.AppendLine(
$"Record {animal.Name} Passport №: {animal.Passport.SerialNumber} successfully imported.");
}
context.Animals.AddRange(validAnimals);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
var sb = new StringBuilder();
var deserializeAnimalAids = JsonConvert.DeserializeObject <AnimalAidDto[]>(jsonString);
var validAnimalAids = new List <AnimalAid>();
foreach (var animalAidDto in deserializeAnimalAids)
{
// If any validation errors occur
// (such as if an animal aid name is too long/ short),
// do not import the entity
var isValid = IsValid(animalAidDto);
// If an animal aid already exists, do not import it
var animalAlreadyExist = validAnimalAids.Any(a => a.Name == animalAidDto.Name);
if (!isValid || animalAlreadyExist)
{
sb.AppendLine(ErrorMessage);
continue;
}
var animalAid = Mapper.Map <AnimalAid>(animalAidDto);
validAnimalAids.Add(animalAid);
sb.AppendLine(string.Format(SuccessfullMessage, animalAid.Name));
}
context.AnimalAids.AddRange(validAnimalAids);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ExportAllProcedures(PetClinicContext context)
{
var procs = context.Procedures
.Select(p => new ExportProcDto
{
DateTime = p.DateTime.ToString("dd-MM-yyyy", CultureInfo.InvariantCulture),
OwnerPhoneNumber = p.Animal.Passport.OwnerName,
SerialNumber = p.Animal.PassportSerialNumber,
TotalPrice = p.ProcedureAnimalAids.Sum(j => j.AnimalAid.Price),
AnimalAids = p.ProcedureAnimalAids.Select(e => e.AnimalAid).Select(e => new ExportAnimalAidDto
{
Name = e.Name,
Price = e.Price
}).ToArray()
}).OrderBy(e => e.DateTime)
.ThenBy(e => e.SerialNumber)
.ToArray();
var serializer = new XmlSerializer(typeof(ExportProcDto[]),
new XmlRootAttribute("Procedures"));
var namespaces = new XmlSerializerNamespaces(new[] { new XmlQualifiedName("", "") });
StringBuilder sb = new StringBuilder();
serializer.Serialize(new StringWriter(sb), procs, namespaces);
return(sb.ToString().TrimEnd());
}
private static void ResetDatabase(PetClinicContext context, bool shouldDeleteDatabase = false)
{
if (shouldDeleteDatabase)
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
context.Database.EnsureCreated();
var disableIntegrityChecksQuery = "EXEC sp_MSforeachtable @command1='ALTER TABLE ? NOCHECK CONSTRAINT ALL'";
context.Database.ExecuteSqlCommand(disableIntegrityChecksQuery);
var deleteRowsQuery = "EXEC sp_MSforeachtable @command1='DELETE FROM ?'";
context.Database.ExecuteSqlCommand(deleteRowsQuery);
var enableIntegrityChecksQuery = "EXEC sp_MSforeachtable @command1='ALTER TABLE ? WITH CHECK CHECK CONSTRAINT ALL'";
context.Database.ExecuteSqlCommand(enableIntegrityChecksQuery);
var reseedQuery = "EXEC sp_MSforeachtable @command1='DBCC CHECKIDENT(''?'', RESEED, 0)'";
try
{
context.Database.ExecuteSqlCommand(reseedQuery);
}
catch (SqlException)
{
}
}
public static string ImportVets(PetClinicContext context, string xmlString)
{
XmlSerializer serializer = new XmlSerializer(typeof(VetDto[]), new XmlRootAttribute("Vets"));
VetDto[] vetDtos = (VetDto[])serializer.Deserialize(new StringReader(xmlString));
StringBuilder sb = new StringBuilder();
List <Vet> validVets = new List <Vet>();
foreach (var vetDto in vetDtos)
{
bool alreadyExists = validVets.Any(v => v.PhoneNumber == vetDto.PhoneNumber);
if (!IsValid(vetDto) || alreadyExists)
{
sb.AppendLine(ErrorMessage);
continue;
}
Vet vet = new Vet
{
Name = vetDto.Name,
Age = vetDto.Age,
Profession = vetDto.Profession,
PhoneNumber = vetDto.PhoneNumber,
};
validVets.Add(vet);
sb.AppendLine(string.Format(ItemSuccessMessage, vet.Name));
}
context.Vets.AddRange(validVets);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ExportAnimalsByOwnerPhoneNumber(PetClinicContext context, string phoneNumber)
{
//Export all animals by their owner's number sorted by age ascending, then by serial number alphabetically.
//Export dates in the format "dd-MM-yyyy", using CultureInfo.InvariantCulture!
var animals = context
.Animals
.Where(x => x.Passport.OwnerPhoneNumber == phoneNumber)
.Select(x => new
{
OwnerName = x.Passport.OwnerName,
AnimalName = x.Name,
x.Age,
SerialNumber = x.PassportSerialNumber,
RegisteredOn = x.Passport.RegistrationDate.ToString("dd-MM-yyyy", CultureInfo.InvariantCulture)
})
.OrderBy(x => x.Age)
.ThenBy(x => x.SerialNumber)
.ToArray();
string json = JsonConvert.SerializeObject(animals, Formatting.Indented);
return(json);
}
public static string ExportAllProcedures(PetClinicContext context)
{
var procedures = context.Procedures
.OrderBy(p => p.DateTime)
.ThenBy(p => p.Animal.PassportSerialNumber)
.Select(p => new ProcedureExportDto()
{
PassportSerialNumber = p.Animal.PassportSerialNumber,
OwnerNumber = p.Animal.Passport.OwnerPhoneNumber,
DateTime = p.DateTime.ToString("dd-MM-yyyy", CultureInfo.InvariantCulture),
AnimalAids = p.ProcedureAnimalAids.Select(paa => new AnimalAidDto()
{
Name = paa.AnimalAid.Name,
Price = paa.AnimalAid.Price
}).ToArray(),
TotalPrice = p.ProcedureAnimalAids.Sum(paa => paa.AnimalAid.Price)
}).ToArray();
var serializerNamespaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
var serializer = new XmlSerializer(typeof(ProcedureExportDto[]), new XmlRootAttribute("Procedures"));
StringWriter writer = new StringWriter();
serializer.Serialize(writer, procedures, serializerNamespaces);
string output = writer.ToString();
return(output);
}
public static string ImportAnimals(PetClinicContext context, string jsonString)
{
var deserializeJson = JsonConvert.DeserializeObject <AnimalDto[]>(jsonString);
var sb = new StringBuilder();
List <Animal> animals = new List <Animal>();
foreach (var animalDto in deserializeJson)
{
var passportExist = animals.Any(x => x.Passport.SerialNumber == animalDto.Passport.SerialNumber);
if (!IsValid(animalDto) ||
!IsValid(animalDto.Passport) ||
passportExist)
{
sb.AppendLine(ERROR_MASSAGE);
continue;
}
var animal = Mapper.Map <Animal>(animalDto);
animals.Add(animal);
sb.AppendLine($"Record {animal.Name} Passport №: {animal.Passport.SerialNumber} successfully imported.");
}
context.Animals.AddRange(animals);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
var animalAids = JsonConvert.DeserializeObject <AnimalAid[]>(jsonString);
var validEntries = new List <AnimalAid>();
var sb = new StringBuilder();
foreach (var animalAid in animalAids)
{
var animalAidExists = validEntries.Any(a => a.Name == animalAid.Name);
if (!IsValid(animalAid) || animalAidExists)
{
sb.AppendLine(FailureMessage);
continue;
}
validEntries.Add(animalAid);
sb.AppendLine(String.Format(SuccessMessage, animalAid.Name));
}
context.AddRange(validEntries);
context.SaveChanges();
return(sb.ToString());
}
public static string ImportAnimals(PetClinicContext context, string jsonString)
{
var animals = JsonConvert.DeserializeObject <AnimalDto[]>(jsonString);
var sb = new StringBuilder();
var validEntries = new List <Animal>();
foreach (var dto in animals)
{
var animal = Mapper.Map <Animal>(dto);
var passportIsValid = IsValid(animal.Passport);
var alreadyExists = validEntries.Any(a => a.Passport.SerialNumber == animal.Passport.SerialNumber);
if (!IsValid(animal) || !passportIsValid || alreadyExists)
{
sb.AppendLine(FailureMessage);
continue;
}
validEntries.Add(animal);
sb.AppendLine(
String.Format(SuccessMessage, $"{animal.Name} Passport №: {animal.Passport.SerialNumber}"));
}
context.Animals.AddRange(validEntries);
context.SaveChanges();
return(sb.ToString());
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
AnimalAid[] deserializedAnimalAids = JsonConvert.DeserializeObject <AnimalAid[]>(jsonString);
List <AnimalAid> validAnimalAids = new List <AnimalAid>();
StringBuilder sb = new StringBuilder();
foreach (var deserializedObj in deserializedAnimalAids)
{
bool alreadyExists = validAnimalAids.Any(aa => aa.Name == deserializedObj.Name);
if (!IsValid(deserializedObj) || alreadyExists)
{
sb.AppendLine(ErrorMessage);
continue;
}
AnimalAid animalAid = new AnimalAid
{
Name = deserializedObj.Name,
Price = deserializedObj.Price,
};
validAnimalAids.Add(animalAid);
sb.AppendLine(string.Format(ItemSuccessMessage, animalAid.Name));
}
context.AnimalAids.AddRange(validAnimalAids);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
var animalAids = JsonConvert.DeserializeObject <AnimalAid[]>(jsonString);
StringBuilder sb = new StringBuilder();
List <AnimalAid> animal = new List <AnimalAid>();
foreach (var animalAid in animalAids)
{
if (!IsValid(animalAid))
{
sb.AppendLine(ErrorMessage);
continue;
}
animal.Add(animalAid);
sb.AppendLine(String.Format(SuccessfulImportAnimalAids, animalAid.Name));
}
//
context.AnimalAids.AddRange(animal);
context.SaveChanges();
//Record {animal aid name} successfully imported.
var result = sb.ToString().ToString();
return(result);
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
AnimalAidDto[] animalAidDtos = JsonConvert.DeserializeObject <AnimalAidDto[]>(jsonString);
StringBuilder sb = new StringBuilder();
List <AnimalAid> animalAids = new List <AnimalAid>();
foreach (AnimalAidDto dto in animalAidDtos)
{
if (!IsValid(dto))
{
sb.AppendLine(ErrorMessage);
continue;
}
if (animalAids.Any(aa => aa.Name == dto.Name))
{
sb.AppendLine(ErrorMessage);
continue;
}
AnimalAid animalAid = new AnimalAid()
{
Name = dto.Name,
Price = dto.Price
};
animalAids.Add(animalAid);
sb.AppendLine(string.Format(SuccessMessage, dto.Name));
}
context.AnimalAids.AddRange(animalAids);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
var sb = new StringBuilder();
var animalAidDtos = JsonConvert.DeserializeObject <ImportAnimalAidDto[]>(jsonString);
var animalAids = new List <AnimalAid>();
foreach (var dto in animalAidDtos)
{
if (!IsValid(dto) || animalAids.Any(a => a.Name == dto.Name))
{
sb.AppendLine(ErrorMessage);
continue;
}
var animalAid = new AnimalAid
{
Name = dto.Name,
Price = dto.Price,
};
sb.AppendLine($"Record {animalAid.Name} successfully imported.");
animalAids.Add(animalAid);
}
context.AnimalAids.AddRange(animalAids);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
private static void ResetDatabase(PetClinicContext context)
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Console.WriteLine("Database reset.");
}
public static string ImportVets(PetClinicContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(VetDto[]), new XmlRootAttribute("Vets"));
var deserXml = (VetDto[])serializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
List <Vet> vets = new List <Vet>();
foreach (var vetDto in deserXml)
{
var phoneExist = vets.Any(x => x.PhoneNumber == vetDto.PhoneNumber);
if (!IsValid(vetDto) || phoneExist)
{
sb.AppendLine(ERROR_MASSAGE);
continue;
}
var vet = Mapper.Map <Vet>(vetDto);
vets.Add(vet);
sb.AppendLine($"Record {vet.Name} successfully imported.");
}
context.Vets.AddRange(vets);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportAnimalAids(PetClinicContext context, string jsonString)
{
var deserializeJson = JsonConvert.DeserializeObject <AnimalAidDto[]>(jsonString);
var sb = new StringBuilder();
List <AnimalAid> animalAids = new List <AnimalAid>();
foreach (var animalAidDto in deserializeJson)
{
var animAidExist = animalAids.Any(x => x.Name == animalAidDto.Name);
if (!IsValid(animalAidDto) || animAidExist)
{
sb.AppendLine(ERROR_MASSAGE);
continue;
}
var animalAid = Mapper.Map <AnimalAid>(animalAidDto);
animalAids.Add(animalAid);
sb.AppendLine($"Record {animalAidDto.Name} successfully imported.");
}
context.AnimalAids.AddRange(animalAids);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportProcedures(PetClinicContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ImportProcedureDTO[]), new XmlRootAttribute("Procedures"));
var proceduresDTO = (ImportProcedureDTO[])serializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
var procedures = new List <Procedure>();
var vets = context.Vets.ToHashSet();
var animals = context.Animals.ToHashSet();
var animalAids = context.AnimalAids.ToHashSet();
foreach (var procedureDTO in proceduresDTO)
{
var vet = vets.FirstOrDefault(x => x.Name == procedureDTO.VetName);
var animal = animals.FirstOrDefault(x => x.PassportSerialNumber == procedureDTO.AnimalSerialNumber);
bool animalAidsIsValid = procedureDTO.AnimalAids.Any(x => animalAids.Any(y => x.Name == y.Name));
bool animalAidsCountIsValid = procedureDTO.AnimalAids.Count == procedureDTO.AnimalAids.Select(x => x.Name).Distinct().Count();
bool procedureIsValid = (vet != null) && (animal != null) && animalAidsCountIsValid && animalAidsIsValid;
if (!IsValid(procedureDTO) || !procedureDTO.AnimalAids.All(IsValid) || !procedureIsValid)
{
sb.AppendLine($"Error: Invalid data.");
continue;
}
var currentProcedureAnimalAids = new List <ProcedureAnimalAid>();
foreach (var animalAidsDTO in procedureDTO.AnimalAids)
{
var animalAid = animalAids.FirstOrDefault(x => x.Name == animalAidsDTO.Name);
var procedureAnimalAid = new ProcedureAnimalAid
{
AnimalAid = animalAid
};
currentProcedureAnimalAids.Add(procedureAnimalAid);
}
var procedure = new Procedure
{
Animal = animal,
Vet = vet,
ProcedureAnimalAids = currentProcedureAnimalAids,
DateTime = DateTime.ParseExact(procedureDTO.DateTime, "dd-MM-yyyy", CultureInfo.InvariantCulture)
};
procedures.Add(procedure);
sb.AppendLine($"Record successfully imported.");
}
context.Procedures.AddRange(procedures);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportAnimals(PetClinicContext context, string jsonString)
{
var animalDto = JsonConvert.DeserializeObject <List <AnimalImportDto> >(jsonString);
StringBuilder sb = new StringBuilder();
var dbAnimalNames = context
.Animals
.Select(a => a.Name)
.ToList();
var validAnimals = new List <Animal>();
foreach (var dto in animalDto)
{
if (!IsValid(dto) ||
!IsValid(dto.Passport) ||
validAnimals.Any(a =>
a.Passport.SerialNumber
== dto.Passport.SerialNumber))
{
sb.AppendLine("Error: Invalid data.");
continue;
}
var animal = new Animal
{
Name = dto.Name,
Type = dto.Type,
Age = dto.Age,
Passport = new Passport
{
SerialNumber = dto.Passport.SerialNumber,
OwnerPhoneNumber = dto.Passport.OwnerPhoneNumber,
OwnerName = dto.Passport.OwnerName,
RegistrationDate = DateTime.ParseExact(dto.Passport.RegistrationDate, "dd-MM-yyyy", CultureInfo.InvariantCulture)
}
};
animal.Passport.Animal = animal;
if (!dbAnimalNames.Contains(animal.Name))
{
validAnimals.Add(animal);
}
else
{
continue;
}
sb.AppendLine($"Record {animal.Name} Passport №: {animal.Passport.SerialNumber} successfully imported.");
}
context.Animals.AddRange(validAnimals);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProcedures(PetClinicContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ProcedureDto[]), new XmlRootAttribute("Procedures"));
var deserializedProcedures = (ProcedureDto[])serializer.Deserialize(new StringReader(xmlString));
List <Procedure> procedures = new List <Procedure>();
List <ProcedureAnimalAid> procedureAnimalAids = new List <ProcedureAnimalAid>();
var sb = new StringBuilder();
foreach (var proc in deserializedProcedures)
{
var vet = context.Vets.SingleOrDefault(v => v.Name == proc.VetName);
var animal = context.Animals.SingleOrDefault(a => a.PassportSerialNumber == proc.AnimalSerialNumber);
if (vet == null ||
animal == null ||
proc.AnimalAids.Length != proc.AnimalAids.Distinct().Count() ||
context.AnimalAids.Where(x => proc.AnimalAids.Any(p => p.Name == x.Name)).Count() != proc.AnimalAids.Count())
{
sb.AppendLine(ErrorMessage);
continue;
}
var procedure = new Procedure()
{
Vet = vet,
Animal = animal,
DateTime = DateTime.ParseExact(proc.DateTime, "dd-MM-yyyy", CultureInfo.InvariantCulture)
};
List <AnimalAid> animalAids = context.AnimalAids.Where(ai => proc.AnimalAids.Any(x => x.Name == ai.Name)).ToList();
foreach (var aid in animalAids)
{
var procedureAnimalAid = new ProcedureAnimalAid()
{
AnimalAid = aid,
Procedure = procedure
};
procedureAnimalAids.Add(procedureAnimalAid);
}
procedures.Add(procedure);
sb.AppendLine(SuccessProcedure);
}
context.Procedures.AddRange(procedures);
context.SaveChanges();
context.ProceduresAnimalAids.AddRange(procedureAnimalAids);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportAnimals(PetClinicContext context, string jsonString)
{
var sb = new StringBuilder();
var animalDtos = JsonConvert.DeserializeObject <ImportAnimalDto[]>(jsonString);
List <Animal> animals = new List <Animal>();
List <Passport> passports = new List <Passport>();
foreach (var animalDto in animalDtos)
{
if (!IsValid(animalDto) || !IsValid(animalDto.Passport))
{
sb.AppendLine("Error: Invalid data.");
continue;
}
var passport = passports.SingleOrDefault(p => p.SerialNumber == animalDto.Passport.SerialNumber);
if (passport == null)
{
passport = new Passport()
{
SerialNumber = animalDto.Passport.SerialNumber,
OwnerName = animalDto.Passport.OwnerName,
OwnerPhoneNumber = animalDto.Passport.OwnerPhoneNumber,
RegistrationDate
= DateTime.ParseExact(animalDto.Passport.RegistrationDate, "dd-MM-yyyy", CultureInfo.InvariantCulture)
};
passports.Add(passport);
}
else
{
sb.AppendLine("Error: Invalid data.");
continue;
}
var animal = new Animal()
{
Age = animalDto.Age,
Name = animalDto.Name,
Passport = passport,
PassportSerialNumber = passport.SerialNumber,
Type = animalDto.Type
};
animals.Add(animal);
sb.AppendLine($"Record {animal.Name} Passport №: {animal.Passport.SerialNumber} successfully imported.");
}
context.Animals.AddRange(animals);
context.Passports.AddRange(passports);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProcedures(PetClinicContext context, string xmlString)
{
XmlSerializer serializer = new XmlSerializer(typeof(ProcedureDTO[]), new XmlRootAttribute("Procedures"));
ProcedureDTO[] deserializedXml = (ProcedureDTO[])serializer.Deserialize(new StringReader(xmlString));
List <Procedure> validProcedures = new List <Procedure>();
StringBuilder sb = new StringBuilder();
foreach (var procedureDTO in deserializedXml)
{
Vet vet = context.Vets.FirstOrDefault(v => v.Name == procedureDTO.Vet);
Animal animal = context.Animals.FirstOrDefault(a => a.PassportSerialNumber == procedureDTO.Animal);
List <ProcedureAnimalAid> validProcedureAnimalAids = new List <ProcedureAnimalAid>();
bool allAidsExists = true;
foreach (var procedureDTOAnimalAid in procedureDTO.AnimalAids)
{
AnimalAid animalAid = context.AnimalAids.FirstOrDefault(a => a.Name == procedureDTOAnimalAid.Name);
if (animalAid == null || validProcedureAnimalAids.Any(a => a.AnimalAid.Name == procedureDTOAnimalAid.Name))
{
allAidsExists = false;
break;
}
ProcedureAnimalAid procedureAnimalAid = new ProcedureAnimalAid()
{
AnimalAid = animalAid
};
validProcedureAnimalAids.Add(procedureAnimalAid);
}
if (!IsValid(procedureDTO) || !procedureDTO.AnimalAids.All(IsValid) || vet == null || animal == null || !allAidsExists)
{
sb.AppendLine(ERROR_MESSAGE);
continue;
}
Procedure procedure = new Procedure()
{
Animal = animal,
Vet = vet,
DateTime = DateTime.ParseExact(procedureDTO.DateTime, "dd-MM-yyyy", CultureInfo.InvariantCulture),
ProcedureAnimalAids = validProcedureAnimalAids
};
validProcedures.Add(procedure);
sb.AppendLine(SUCCESS_MESSAGE_PROCEDURES);
}
context.Procedures.AddRange(validProcedures);
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportProcedures(PetClinicContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(ProcedureDto[]), new XmlRootAttribute("Procedures"));
var deserialized = (ProcedureDto[])serializer.Deserialize(new StringReader(xmlString));
var validProcedures = new List <Procedure>();
var sb = new StringBuilder();
foreach (var procedureDto in deserialized)
{
var vetObj = context.Vets.SingleOrDefault(x => x.Name == procedureDto.Vet);
var animalObj = context.Animals.SingleOrDefault(x => x.PassportSerialNumber == procedureDto.Animal);
var validProceduresAnimalAids = new List <ProcedureAnimalAid>();
var allAidsExist = true;
foreach (var procedureDtoAnimalAid in procedureDto.AnimalAids)
{
var animalAidExist =
context.AnimalAids.SingleOrDefault(ai => ai.Name == procedureDtoAnimalAid.Name);
if (animalAidExist == null || validProceduresAnimalAids.Any(p => p.AnimalAid.Name == procedureDtoAnimalAid.Name))
{
allAidsExist = false;
break;
}
var animalAidProcedure = new ProcedureAnimalAid()
{
AnimalAid = animalAidExist
};
validProceduresAnimalAids.Add(animalAidProcedure);
}
if (!IsValid(procedureDto) || vetObj == null || !procedureDto.AnimalAids.All(IsValid) || vetObj == null || animalObj == null || !allAidsExist)
{
sb.AppendLine(ERROR_MESSAGE);
continue;
}
var proc = new Procedure()
{
Animal = animalObj,
Vet = vetObj,
DateTime = DateTime.ParseExact(procedureDto.DateTime, "dd-MM-yyyy", CultureInfo.InvariantCulture),
ProcedureAnimalAids = validProceduresAnimalAids
};
validProcedures.Add(proc);
sb.AppendLine("Record successfully imported.");
}
context.Procedures.AddRange(validProcedures);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProcedures(PetClinicContext context, string xmlString)
{
var sb = new StringBuilder();
var procedures = new List <Procedure>();
var vets = context.Vets.ToList();
var animals = context.Animals.ToList();
var animalAids = context.AnimalAids.ToList();
var serializer = new XmlSerializer(typeof(ImportProcedureDto[]), new XmlRootAttribute("Procedures"));
ImportProcedureDto[] importProcedureDtos;
using (var reader = new StringReader(xmlString))
{
importProcedureDtos = (ImportProcedureDto[])serializer.Deserialize(reader);
}
foreach (var dto in importProcedureDtos)
{
var vetIsValid = vets.Any(v => v.Name == dto.Vet);
var animalIsValid = animals.Any(a => a.PassportSerialNumber == dto.Animal);
var animalAidsAreValid = dto.AnimalAids.All(aa => animalAids.Any(a => a.Name == aa.Name));
//check all animalAids are unique
var animalAidsNames = dto.AnimalAids.Select(aa => aa.Name).ToList();
var namesAreUnique = animalAidsNames.Count() == animalAidsNames.Distinct().ToList().Count();
if (!IsValid(dto) || !vetIsValid || !animalIsValid || !animalAidsAreValid || !namesAreUnique)
{
sb.AppendLine(ErrorMessage);
continue;
}
var procedure = new Procedure
{
Vet = vets.First(v => v.Name == dto.Vet),
Animal = animals.First(a => a.PassportSerialNumber == dto.Animal),
DateTime = DateTime.ParseExact(dto.DateTime, @"dd-MM-yyyy", CultureInfo.InvariantCulture),
ProcedureAnimalAids = dto.AnimalAids.Select(aa => new ProcedureAnimalAid
{
AnimalAid = animalAids.First(a => a.Name == aa.Name)
})
.ToArray()
};
sb.AppendLine("Record successfully imported.");
procedures.Add(procedure);
}
context.Procedures.AddRange(procedures);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportAnimals(PetClinicContext context, string jsonString)
{
var sb = new StringBuilder();
var importedAnimals = JsonConvert.DeserializeObject <AnimalToImportDto[]>(jsonString, new IsoDateTimeConverter {
DateTimeFormat = "dd-MM-yyyy"
});
var validPassports = new List <Passport>();
var validAnimals = new List <Animal>();
var validAnimalAids = new List <AnimalAid>();
foreach (var importedAnimal in importedAnimals)
{
if (!IsValid(importedAnimal) || !IsValid(importedAnimal.Passport) || validPassports.Any(p => p.SerialNumber == importedAnimal.Passport.SerialNumber))
{
sb.AppendLine(ErrorMessage);
continue;
}
var validPassport = new Passport()
{
OwnerName = importedAnimal.Passport.OwnerName,
OwnerPhoneNumber = importedAnimal.Passport.OwnerPhoneNumber,
RegistrationDate = importedAnimal.Passport.RegistrationDate,
SerialNumber = importedAnimal.Passport.SerialNumber,
};
var validAnimal = new Animal()
{
Age = importedAnimal.Age,
Type = importedAnimal.Type,
Name = importedAnimal.Name,
Passport = validPassport
};
validPassport.Animal = validAnimal;
validAnimals.Add(validAnimal);
validPassports.Add(validPassport);
sb.AppendLine($"Record {validAnimal.Name} Passport №: {validPassport.SerialNumber} successfully imported.");
}
context.Animals.AddRange(validAnimals);
context.Passports.AddRange(validPassports);
context.SaveChanges();
return(sb.ToString().TrimEnd('\n', '\r'));
}
