public void SequenceOfScalarsToXml()
{
YamlDocument yaml = GetDocument("test8.yaml");
XmlConverter converter = new XmlConverter();
XmlDocument xml = converter.ToXml(yaml);
xml.Save(Console.Out);
}
public async Task HappyPath_ManyUniquePrnsGeneratedAndSeedUpdatedToExpectedValue()
{
// arrange
var validXmlLocation = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase), @"ExampleXML\v3-valid-many-insertions.xml");
var validXmlString = File.ReadAllText(new Uri(validXmlLocation).LocalPath);
var validXmlBytes = File.ReadAllBytes(new Uri(validXmlLocation).LocalPath);
using (var database = new DatabaseWrapper())
{
var modelHelper = new ModelHelper(database.Model);
var org = modelHelper.CreateOrganisation();
var scheme = modelHelper.CreateScheme(org);
var memberUpload = modelHelper.CreateMemberUpload(scheme);
var message = new ProcessXmlFile(org.Id, validXmlBytes, "File name");
var initialSeed = database.WeeeContext.SystemData.Select(sd => sd.LatestPrnSeed).First();
var expectedSeed = ExpectedSeedAfterThisXml(validXmlString, initialSeed);
var whiteSpaceCollapser = A.Fake<IWhiteSpaceCollapser>();
var xmlConverter = new XmlConverter(whiteSpaceCollapser, new Deserializer());
var schemeType = xmlConverter.Deserialize<schemeType>(xmlConverter.Convert(message.Data));
var producerCharges = new Dictionary<string, ProducerCharge>();
var anyAmount = 30;
var anyChargeBandAmount = A.Dummy<ChargeBandAmount>();
foreach (var producerData in schemeType.producerList)
{
var producerName = producerData.GetProducerName();
if (!producerCharges.ContainsKey(producerName))
{
producerCharges.Add(producerName,
new ProducerCharge { Amount = anyAmount, ChargeBandAmount = anyChargeBandAmount });
}
}
database.Model.SaveChanges();
var contextMemberUpload = database.WeeeContext.MemberUploads
.Single(mu => mu.Id == memberUpload.Id);
// act
var producers = await new GenerateFromXml(
xmlConverter,
new GenerateFromXmlDataAccess(database.WeeeContext)).GenerateProducers(message, contextMemberUpload, producerCharges);
// assert
long newSeed = database.WeeeContext.SystemData.Select(sd => sd.LatestPrnSeed).First();
Assert.Equal(expectedSeed, newSeed);
var prns = producers.Select(p => p.RegisteredProducer.ProducerRegistrationNumber);
Assert.Equal(prns.Distinct(), prns); // all prns should be unique
}
}
public void FromXmlNullOnNullXml()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
string xml = null;
// Act
var candidate = converter.FromXml<Content>(xml);
// Assert
Assert.IsNull(candidate);
}
public int Execute(string []args)
{
TextReader input = Console.In;
TextWriter output = Console.Out;
if (args.Length > 2)
{
Usage();
return 1;
}
if (args.Length >= 1)
{
try
{
input = new StreamReader(args[0]);
}
catch (Exception ex)
{
Console.Error.WriteLine("c2xml: Unable to open file {0} for reading. {1}", args[0], ex.Message);
Usage();
return 1;
}
}
if (args.Length == 2)
{
try
{
output = new StreamWriter(args[1]);
}
catch (Exception ex)
{
Console.Error.WriteLine("c2xml: Unable to open file {0} for writing. {1}", args[1], ex.Message);
return 1;
}
}
var xWriter = new XmlTextWriter(output)
{
Formatting = Formatting.Indented
};
XmlConverter c = new XmlConverter(input, xWriter);
c.Convert();
output.Flush();
return 0;
}
public void FromXmlErrorOnInvalidXml()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
// Act
try
{
converter.FromXml<Content>("<Test>");
throw new Exception("Should be MappingException");
}
catch (MappingException)
{
// Don't bother checking actual error message - too fragile
}
}
public void Roundtrip()
{
YamlDocument yaml = GetDocument("test10.yaml");
XmlConverter converter = new XmlConverter();
XmlDocument xml = converter.ToXml(yaml);
StringWriter firstBuffer = new StringWriter();
xml.Save(firstBuffer);
Console.Out.Write(firstBuffer.ToString());
YamlDocument intermediate = converter.FromXml(xml);
XmlDocument final = converter.ToXml(intermediate);
StringWriter secondBuffer = new StringWriter();
final.Save(secondBuffer);
Console.Error.Write(secondBuffer.ToString());
Assert.AreEqual(firstBuffer.ToString(), secondBuffer.ToString(), "The first and second XML are different.");
}
public void FromXmlConvertXmlBasedOnVersion()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var engine = new Mock<IXmlMappingEngine>();
var converter = new XmlConverter(detector.Object, factory.Object);
var expected = new Content { Name = "Fred" };
detector.Setup(x => x.DetectSchemaVersion(It.IsAny<XElement>())).Returns("V1");
factory.Setup(x => x.Find("V1")).Returns(engine.Object);
engine.Setup(x => x.Map<XPathProcessor, Content>(It.IsAny<XPathProcessor>())).Returns(expected);
// Act
var candidate = converter.FromXml<Content>("<Test></Test>");
// Assert
Assert.AreSame(expected, candidate, "Not same");
}
public static string ImportCars(CarDealerContext context, string inputXml)
{
const string root = "Cars";
var carsDto = XmlConverter.Deserializer <CarInputModel>(inputXml, root);
var cars = new List <Car>();
var allParts = context.Parts.Select(x => x.Id).ToList();
foreach (var currentCar in carsDto)
{
var distinctedParts = currentCar.Parts.Select(x => x.Id).Distinct();
var parts = distinctedParts.Intersect(allParts);
var car = new Car
{
Make = currentCar.Make,
Model = currentCar.Model,
TravelledDistance = currentCar.TraveledDistance
};
foreach (var part in parts)
{
var partCar = new PartCar
{
PartId = part
};
car.PartCars.Add(partCar);
}
cars.Add(car);
}
context.AddRange(cars);
context.SaveChanges();
return($"Successfully imported {cars.Count}");
}
public static string GetTotalSalesByCustomer(CarDealerContext context)
{
var customers = context
.Customers
.Where(x => x.Sales.Count >= 1)
.Select(x => new ExportCustomerTotalSalesDTO
{
Name = x.Name,
BoughtCars = x.Sales.Count,
SpentMoney = x.Sales
.Select(s => s.Car.PartCars.
Sum(pc => pc.Part.Price))
.Sum()
}).ToList()
.OrderByDescending(x => x.SpentMoney)
.ToList();
var result = XmlConverter.Serialize(customers, "customers");
return(result);
}
public static string ImportSales(CarDealerContext context, string inputXml)
{
const string root = "Sales";
var validCars = context.Cars.Select(x => x.Id).ToList();
var salesDto = XmlConverter.Deserializer <SaleInputModel>(inputXml, root);
var sales = salesDto
.Where(x => validCars.Contains(x.CarId))
.Select(x => new Sale
{
CarId = x.CarId,
CustomerId = x.CustomerId,
Discount = x.Discount
})
.ToList();
context.Sales.AddRange(sales);
context.SaveChanges();
return($"Successfully imported {sales.Count}");
}
//19. Sales with Applied Discount 3:00:00
public static string GetSalesWithAppliedDiscount(CarDealerContext context)
{
var result = context.Sales
.Select(s => new ExportSaleDto
{
Car = new ExportCarDto
{
Make = s.Car.Make,
Model = s.Car.Model,
TraveledDistance = s.Car.TravelledDistance
},
Discount = s.Discount,
CustomerName = s.Customer.Name,
Price = s.Car.PartCars.Sum(p => p.Part.Price),
PriceWithDiscount = s.Car.PartCars.Sum(p => p.Part.Price) - s.Car.PartCars.Sum(p => p.Part.Price) * s.Discount / 100.00M
})
.ToArray();
var xmlResult = XmlConverter.Serialize(result, "sales");
return(xmlResult);
}
private void Merge_click(object sender, RoutedEventArgs e)
{
fsw.EnableRaisingEvents = false;
SelectMergeOption win = new SelectMergeOption();
if (win.ShowDialog() == true)
{
OpenFileDialog diag = new OpenFileDialog();
diag.Title = "Select vesselData file";
diag.Filter = "VesselData files (*vesselData*.xml)|*vesselData*.xml|All Files|*.*";
diag.CheckFileExists = true;
diag.CheckPathExists = true;
if (diag.ShowDialog() == true)
{
VesselDataObject ImportObject = XmlConverter.ToObject(diag.FileName, typeof(VesselDataObject)) as VesselDataObject;
MergeRacesAndVessels(ImportObject, win.KeepSource, win.KeepTarget, win.Prompt);
}
SetWatcher(WorkFile);
}
}
public void ToXmlPreservesEngineFactoryMappingException()
{
// Arrange
var detector = new Mock <IXmlVersionDetector>();
var factory = new Mock <IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
factory.Setup(x => x.Find("V1")).Throws(new MappingException("Hello world"));
// Act
try
{
converter.ToXml(new Content(), "V1");
throw new Exception("Should be MappingException");
}
catch (MappingException ex)
{
Assert.AreEqual("Hello world", ex.Message);
}
}
//02.ImportProducts
public static string ImportProducts(ProductShopContext context, string inputXml)
{
const string root = "Products";
var productsDto = XmlConverter
.Deserializer <ProductsInputModel>(inputXml, root);
var products = productsDto
.Select(p => new Product
{
Name = p.Name,
Price = p.Price,
SellerId = p.SellerId,
BuyerId = p.BuyerId
})
.ToList();
context.Products.AddRange(products);
context.SaveChanges();
return($"Successfully imported {products.Count()}");
}
/// <summary>
/// This method Import and Deserioalize the Suppliers from Xml file suppliers to SuplierInputModel to the Databese
/// </summary>
/// 9th Exercise
public static string ImportSuppliers(CarDealerContext context, string inputXml)
{
var root = "Suppliers";
var suppliersDto = XmlConverter.Deserializer <SupplierInputModel>(inputXml, root);
//var serializer = new XmlSerializer(typeof(SupplierInputModel[]), new XmlRootAttribute("Suppliers"));
//var textRead = new StringReader(inputXml);
//var suppliersDto = serializer.Deserialize(textRead) as SupplierInputModel[];
var suppliers = suppliersDto.Select(x => new Supplier
{
Name = x.Name,
IsImporter = x.IsImporter,
})
.ToList();
context.Suppliers.AddRange(suppliers);
context.SaveChanges();
return($"Successfully imported {suppliers.Count}");
}
public static string GetSalesWithAppliedDiscount(CarDealerContext context)
{
var sales = context.Sales
.Select(x => new SalesOutputModel
{
Car = new CarSaleOutputModel
{
Make = x.Car.Make,
Model = x.Car.Model,
TravelledDistance = x.Car.TravelledDistance
},
Discount = x.Discount,
CustomerName = x.Customer.Name,
Price = x.Car.PartCars.Sum(x => x.Part.Price),
PriceWithDiscount = x.Car.PartCars.Sum(x => x.Part.Price) - x.Car.PartCars.Sum(x => x.Part.Price) * x.Discount / 100
})
.ToList();
var result = XmlConverter.Serialize(sales, "sales");
return(result);
}
public static string ImportCustomers(CarDealerContext context, string inputXml)
{
const string root = "Customers";
InitializeAutomapper();
var customersDto = XmlConverter.Deserializer <CustomerInputModel>(inputXml, root);
var customers = customersDto
.Select(x => new Customer
{
Name = x.Name,
BirthDate = x.BirthDate,
IsYoungDriver = x.IsYoungDriver
})
.ToList();
context.Customers.AddRange(customers);
context.SaveChanges();
return($"Successfully imported {customers.Count}");
}
public void Roundtrip()
{
var yaml = GetDocument("test10.yaml");
var converter = new XmlConverter();
var xml = converter.ToXml(yaml);
var firstBuffer = new StringWriter();
xml.Save(firstBuffer);
Dump.Write(firstBuffer);
var intermediate = converter.FromXml(xml);
var final = converter.ToXml(intermediate);
var secondBuffer = new StringWriter();
final.Save(secondBuffer);
Dump.Write(secondBuffer);
Assert.Equal(firstBuffer.ToString(), secondBuffer.ToString());
}
//Task11
public static string GetSalesWithAppliedDiscount(CarDealerContext context)
{
ExportSaleInfoDto[] salesInfo = context.Sales
.Select(x => new ExportSaleInfoDto
{
Car = new ExportCarAttributeDto
{
Make = x.Car.Make,
Model = x.Car.Model,
TravelledDistance = x.Car.TravelledDistance
},
Discount = x.Discount,
CustomerName = x.Customer.Name,
Price = x.Car.PartCars.Sum(x => x.Part.Price),
PriceWithDiscount = x.Car.PartCars.Sum(x => x.Part.Price) - x.Car.PartCars.Sum(x => x.Part.Price) * x.Discount / 100
})
.ToArray();
string result = XmlConverter.Serialize <ExportSaleInfoDto>(salesInfo, "sales");
return(result);
}
public void ConvertGridLayerTest()
{
const string excelFilePath = @"C:\Artsdatabanken\NIBIO\SSB1000test.xlsx";
var gridLayer = GridLayerImpl.FromExcelFile(excelFilePath, RutenettType.SSB001KM, "Antall landbruk Test", 2);
gridLayer.Established = new DateTime(2016, 3, 7);
gridLayer.Code = new Code
{
Value = "LB",
Registry = "NiN",
Version = "2.0"
};
gridLayer.Owner = new Contact
{
Company = "NIBIO",
Homesite = "www.nibio.no"
};
var gridXml = new XmlConverter().ToXml(gridLayer);
gridXml.Save(@"C:\Artsdatabanken\KartTestData\RuteNettKartLandbruk.xml");
}
public void ConvertTemperatureGridLayerTest()
{
const string excelFilePath = @"C:\Artsdatabanken\NIBIO\NIBO_SSB_5x5_export.xlsx";
var gridLayer = GridLayerImpl.FromExcelFile(excelFilePath, RutenettType.SSB005KM, "Temperatur Test", 6);
gridLayer.Established = new DateTime(2016, 3, 7);
gridLayer.Code = new Code
{
Value = "TEMP",
Registry = "NiN",
Version = "2.0"
};
gridLayer.Owner = new Contact
{
Company = "NIBIO",
Homesite = "www.nibio.no"
};
var gridXml = new XmlConverter().ToXml(gridLayer);
gridXml.Save(@"C:\Artsdatabanken\KartTestData\RuteNettKartTemperatur.xml");
}
//04.ImportCategoryProducts
public static string ImportCategoryProducts(ProductShopContext context, string inputXml)
{
var root = "CategoryProducts";
var data = XmlConverter.Deserializer <ImportCategoryProductDTO>(inputXml, root);
//var categoryProducts = data.Select(x => new CategoryProduct
//{
// CategoryId = x.CategoryId,
// ProductId = x.ProductId
//})
//.ToArray();
var categories = data.Select(x => new CategoryProduct
{
CategoryId = x.CategoryId,
ProductId = x.ProductId
})
.ToArray();
List <CategoryProduct> categoryProducts = new List <CategoryProduct>();
foreach (var item in categories)
{
var existCategory = context.Categories.Any(x => x.Id == item.CategoryId);
var existProduct = context.Products.Any(x => x.Id == item.ProductId);
if (!existCategory || !existProduct)
{
continue;
}
categoryProducts.Add(item);
}
context.CategoryProducts.AddRange(categoryProducts);
context.SaveChanges();
return($"Successfully imported {categoryProducts.Count}");
}
public static string GetUsersWithProducts(ProductShopContext context)
{
const string root = "Users";
var userWithProductsDto = new ExportsUsersWithProducts()
{
Count = context.Users.Count(u => u.ProductsSold.Any(p => p.Buyer != null)),
Users = context.Users
.ToArray()
.Where(x => x.ProductsSold.Any(p => p.Buyer != null))
.Select(x => new ListOfUsers()
{
FirstName = x.FirstName,
LastName = x.LastName,
Age = x.Age,
SoldProducts = new ProductsSold()
{
Count = x.ProductsSold.Count(ps => ps.Buyer != null),
Products = x.ProductsSold
.Where(ps => ps.Buyer != null)
.Select(y => new ExportProductItemSold
{
Name = y.Name,
Price = y.Price
})
.OrderByDescending(x => x.Price)
.ToArray()
}
})
.OrderByDescending(x => x.SoldProducts.Count)
.Take(10)
.ToArray()
};
var Xml = XmlConverter.Serialize(userWithProductsDto, root);
return(Xml);
}
////Problem - 11
public static string ImportCars(CarDealerContext context, string inputXml)
{
const string rootElement = "Cars";
ImportCarDTO[] carsDTOs = XmlConverter.Deserializer <ImportCarDTO>(inputXml, rootElement);
List <Car> newCars = new List <Car>();
List <PartCar> newParts = new List <PartCar>();
foreach (var car in carsDTOs)
{
Car newCar = new Car()
{
Make = car.Make,
Model = car.Model,
TravelledDistance = car.TraveledDistance,
};
newCars.Add(newCar);
foreach (var part in car.CarParts.Select(x => new { partId = x.PartId }).Distinct())
{
PartCar newPart = new PartCar()
{
PartId = part.partId,
Car = newCar
};
newParts.Add(newPart);
}
}
context.Cars.AddRange(newCars);
context.PartCars.AddRange(newParts);
context.SaveChanges();
return($"Successfully imported {carsDTOs.Count()}");
}
void RunTest(string c_code, string expectedXml, string dialect)
{
StringReader reader = null;
StringWriter writer = null;
try
{
reader = new StringReader(c_code);
writer = new StringWriter();
//var xWriter = new XmlTextWriter(writer)
var xWriter = new XmlnsHidingWriter(writer)
{
Formatting = Formatting.Indented
};
var arch = new FakeArchitecture(new ServiceContainer());
var platform = new DefaultPlatform(null, arch);
var xc = new XmlConverter(reader, xWriter, platform, true, dialect);
xc.Convert();
writer.Flush();
Assert.AreEqual(expectedXml, writer.ToString());
}
catch
{
Debug.WriteLine(writer.ToString());
throw;
}
finally
{
if (writer != null)
{
writer.Dispose();
}
if (reader != null)
{
reader.Dispose();
}
}
}
//03. Import Categories
public static string ImportCategories(ProductShopContext context, string inputXml)
{
const string rootElement = "Categories";
var categoriesDtio = XmlConverter.Deserializer <ImportCategoryDto>(inputXml, rootElement);
var categories = categoriesDtio
.Where(c => c.Name != null)
.Select(p => new Category
{
Name = p.Name
})
.ToArray();
/*
* List<Category> categories = new List<Category>();
*
* foreach (var dto in categoriesDtio)
* {
* if (dto.Name == null)
* {
* continue;
* }
*
* var category = new Category
* {
* Name = dto.Name
* };
*
* categories.Add(category);
* }
*/
context.Categories.AddRange(categories);
context.SaveChanges();
return($"Successfully imported {categories.Length}");
}
//Problem - 01
public static string ImportUsers(ProductShopContext context, string inputXml)
{
string rootElement = "Users";
var usersDTO = XmlConverter.Deserializer <ImportUserDTO>(inputXml, rootElement);
;
var users = usersDTO
.Select(u => new User
{
FirstName = u.FirstName,
LastName = u.LastName,
Age = u.Age
})
.ToList();
context.Users.AddRange(users);
context.SaveChanges();
return($"Successfully imported {users.Count}");
//var users = new List<User>();
//foreach (var user in usersDTO)
//{
// var newUser = new User
// {
// FirstName = user.FirstName,
// LastName = user.LastName,
// Age = user.Age
// };
// users.Add(newUser);
//}
//context.Users.AddRange(users);
//context.SaveChanges();
//return $"Successfully imported {users.Count}";
}
public static string GetSoldProducts(ProductShopContext context)
{
var users = context.Users
.Where(x => x.ProductsSold.Count > 0)
.OrderBy(x => x.LastName)
.ThenBy(x => x.FirstName)
.Select(x => new SoldProductsOutputMondel
{
FirstName = x.FirstName,
LastName = x.LastName,
SoldProducts = x.ProductsSold.Select(ps => new SoldProductsModel
{
Name = ps.Name,
Price = ps.Price,
}).ToList()
})
.Take(5)
.ToList();
var xml = XmlConverter.Serialize(users, "Users");
return(xml);
}
public static string GetSalesWithAppliedDiscount(CarDealerContext context)
{
var salesWithDiscount = context.Sales
.Select(x => new SalesWithDiscountDTO
{
Car = new CarDetails
{
Make = x.Car.Make,
Model = x.Car.Model,
TravelledDistance = x.Car.TravelledDistance
},
Discount = x.Discount,
CustomerName = x.Customer.Name,
Price = x.Car.PartCars.Sum(y => y.Part.Price)
})
.ToArray();
foreach (var sale in salesWithDiscount)
{
sale.PriceWithDiscount = sale.Price - (sale.Price * sale.Discount / 100.0M);
}
return(XmlConverter.Serialize(salesWithDiscount, "sales"));
}
public void ToXmlWrapsEngineFactoryException()
{
// Arrange
var detector = new Mock <IXmlVersionDetector>();
var factory = new Mock <IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
factory.Setup(x => x.Find("V1")).Throws <ArgumentNullException>();
// Act
try
{
converter.ToXml(new Content(), "V1");
throw new Exception("Should be MappingException");
}
catch (MappingException ex)
{
Assert.AreEqual("IXmlMappingEngine not found: V1", ex.Message);
Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentNullException));
}
}
private static void GetPlaylistsAndSongsIndexAndShuffle(ValueSet valueSet)
{
string currentSongPath = CurrentSong.Path;
string path = valueSet["Path"].ToString();
string[] parts = valueSet["PlaylistsAndSongsIndexAndShuffle"].ToString().Split(';');
int playlistIndex = int.Parse(parts[0]);
int songsIndex = int.Parse(parts[1]);
if (Library.Current[playlistIndex][songsIndex].Path != path &&
!Library.Current.HavePlaylistIndexAndSongsIndex(path, out playlistIndex, out songsIndex))
{
return;
}
Library.Current.CurrentPlaylistIndex = playlistIndex;
Library.Current.CurrentPlaylist.SongsIndex = songsIndex;
Library.Current.CurrentPlaylist.Shuffle = XmlConverter.Deserialize <ShuffleKind>(valueSet["ShuffleKind"].ToString());
Library.Current.CurrentPlaylist.ShuffleList = XmlConverter.Deserialize <List <int> >(valueSet["ShuffleList"].ToString());
PlaySongIfOther(currentSongPath);
}
//Problem - 04
public static string ImportCategoryProducts(ProductShopContext context, string inputXml)
{
string rootElement = "CategoryProducts";
var categoryProductDTOs = XmlConverter.Deserializer <ImportCategoryProductDTO>(inputXml, rootElement);
var categoriesCount = context.Categories.Count();
var productsCount = context.Products.Count();
var categoriesProducts = categoryProductDTOs
.Where(x => x.CategoryId <= categoriesCount && x.ProductId <= productsCount)
.Select(cp => new CategoryProduct
{
CategoryId = cp.CategoryId,
ProductId = cp.ProductId
})
.ToList();
context.CategoryProducts.AddRange(categoriesProducts);
context.SaveChanges();
return($"Successfully imported {categoriesProducts.Count}");
}
public static string GetCarsWithTheirListOfParts(CarDealerContext context)
{
var carsWithParts = context.Cars
.Select(x => new CarWithPartsExportDTO
{
Make = x.Make,
Model = x.Model,
TravelledDistance = x.TravelledDistance,
Parts = x.PartCars.Select(y => new CarPartsDTO
{
Name = y.Part.Name,
Price = y.Part.Price
})
.OrderByDescending(x => x.Price)
.ToArray()
})
.OrderByDescending(x => x.TravelledDistance)
.ThenBy(x => x.Model)
.Take(5)
.ToArray();
return(XmlConverter.Serialize(carsWithParts, "cars"));
}
public static string ImportUsers(ProductShopContext context, string inputXml)
{
const string rootElement = "Users";
var usersResult = XmlConverter.Deserializer <ImportUserDto>(inputXml, rootElement);
List <User> users = new List <User>();
foreach (var importUserDto in usersResult)
{
var user = new User
{
FirstName = importUserDto.FirstName,
LastName = importUserDto.LastName,
Age = importUserDto.Age
};
users.Add(user);
}
context.Users.AddRange(users);
context.SaveChanges();
return($"Successfully imported {users.Count}");
}
public void ReadXml(XmlReader reader)
{
double currentSongPosition = double.Parse(reader.GetAttribute("CurrentSongPosition") ?? "0");
AbsolutePath = reader.GetAttribute("AbsolutePath") ?? emptyOrLoadingPath;
Name = reader.GetAttribute("Name") ?? emptyName;
Loop = (LoopType)Enum.Parse(typeof(LoopType), reader.GetAttribute("Loop") ?? LoopType.Off.ToString());
string currentSongPath = reader.GetAttribute("CurrentSongPath") ?? string.Empty;;
ShuffleType shuffle = (ShuffleType)Enum.Parse(typeof(ShuffleType),
reader.GetAttribute("Shuffle") ?? ShuffleType.Off.ToString());
reader.ReadStartElement();
ISongCollection songs = reader.Name == typeof(SongCollection).Name ?
(ISongCollection) new SongCollection() : new SimpleSongCollection();
songs.Parent = this;
Songs = XmlConverter.Deserialize(songs, reader.ReadOuterXml());
CurrentSong = songs.FirstOrDefault(s => s.Path == currentSongPath) ?? songs.FirstOrDefault();
CurrentSongPosition = currentSongPosition;
}
public static string GetSalesWithAppliedDiscount(CarDealerContext context)
{
var sales = context.Sales
.Select(s => new SaleWithDiscountOutputModel
{
Car = new CarSaleOutputModel
{
Make = s.Car.Make,
Model = s.Car.Model,
TravelledDistance = s.Car.TravelledDistance,
},
Discount = s.Discount,
CustomerName = s.Customer.Name,
Price = s.Car.PartCars.Sum(pc => pc.Part.Price),
PriceWithDiscount = s.Car.PartCars.Sum(pc => pc.Part.Price) -
s.Car.PartCars.Sum(pc => pc.Part.Price) * s.Discount / 100m
})
.ToArray();
var result = XmlConverter.Serialize(sales, "sales");
return(result);
}
// 18.Total Sales by Customer
public static string GetTotalSalesByCustomer(CarDealerContext context)
{
/*Get all customers that have bought at least 1 car and get their names, bought cars count and total spent money on cars.
* Order the result list by total spent money descending.*/
var result = context
.Customers
.Where(c => c.Sales.Any())
.Select(c => new TotalSalesByCustomerDto
{
FullName = c.Name,
BoughtCars = c.Sales.Count,
SpentMoney = c.Sales
.Select(s => s.Car)
.SelectMany(cars => cars.PartCars)
.Sum(pc => pc.Part.Price)
})
.OrderByDescending(c => c.SpentMoney)
.ToList();
var xml = XmlConverter.Serialize(result, "customers");
return(xml);
}
public void FromXmlErrorOnVersionDetectionFailure()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
detector.Setup(x => x.DetectSchemaVersion(It.IsAny<XElement>())).Returns(string.Empty);
// Act
try
{
converter.FromXml<Content>("<Test></Test>");
throw new Exception("Should be MappingException");
}
catch (MappingException)
{
// Don't bother checking actual error message - too fragile
// Ensure we tried to find out the version
detector.Verify(x => x.DetectSchemaVersion(It.IsAny<XElement>()));
}
}
public int Execute(string [] args)
{
TextReader input = Console.In;
TextWriter output = Console.Out;
var sc = new ServiceContainer();
var rekoCfg = RekoConfigurationService.Load();
sc.AddService<IConfigurationService>(rekoCfg);
var docopt = new Docopt();
IDictionary<string, ValueObject> options;
try {
options = docopt.Apply(usage, args);
} catch (Exception ex)
{
Console.Error.WriteLine(ex);
return 1;
}
var arch = rekoCfg.GetArchitecture(options["-a"].ToString());
if (arch == null)
{
Console.WriteLine(
"c2xml: unknown architecture '{0}'. Check the c2xml config file for supported architectures.",
options["-a"]);
return -1;
}
var envElem = rekoCfg.GetEnvironment(options["-e"].ToString());
if (envElem == null)
{
Console.WriteLine(
"c2xml: unknown environment '{0}'. Check the c2xml config file for supported architectures.",
options["-e"]);
return -1;
}
var platform = envElem.Load(sc, arch);
try
{
input = new StreamReader(options["<inputfile>"].ToString());
}
catch (Exception ex)
{
Console.Error.WriteLine("c2xml: unable to open file {0} for reading. {1}", options["<inputfile>"], ex.Message);
return 1;
}
if (options.ContainsKey("<outputfile>") &&
options["<outputfile>"] != null)
{
try
{
output = new StreamWriter(options["<outputfile>"].ToString());
}
catch (Exception ex)
{
Console.Error.WriteLine("c2xml: unable to open file {0} for writing. {1}", options["<outputfile>"], ex.Message);
return 1;
}
}
var xWriter = new XmlTextWriter(output)
{
Formatting = Formatting.Indented
};
XmlConverter c = new XmlConverter(input, xWriter, platform);
c.Convert();
output.Flush();
return 0;
}
public void ToXmlFailOnUnregisteredEngineVersion()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var engine = new Mock<IXmlMappingEngine>();
var converter = new XmlConverter(detector.Object, factory.Object);
factory.Setup(x => x.Find("V1")).Returns(engine.Object);
engine.Setup(x => x.CreateDocument(It.IsAny<Content>())).Throws<ArgumentNullException>();
// Act
try
{
converter.ToXml(new Content(), "V1");
throw new Exception("Should be MappingException");
}
catch (MappingException)
{
// Assert
// Don't bother checking actual error message - too fragile
// Ensure we asked for the correct version.
factory.Verify(x => x.Find("V1"));
}
}
/// <summary>
/// Invokes <see cref="XmlConverter.ToXml"/>.
/// </summary>
public static XmlDocument ToXml(this YamlDocument document)
{
XmlConverter converter = new XmlConverter();
return converter.ToXml(document);
}
public void ConvertNodeWithoutAttributes(string input, string expected)
{
var sut = new XmlConverter(attributeBullet: null);
var output = sut.Convert(input);
Assert.AreEqual(expected, output);
}
public void ToXmlPreservesEngineMappingException()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var engine = new Mock<IXmlMappingEngine>();
var converter = new XmlConverter(detector.Object, factory.Object);
factory.Setup(x => x.Find("V1")).Returns(engine.Object);
engine.Setup(x => x.CreateDocument(It.IsAny<Content>())).Throws(new MappingException("Hello world"));
// Act
try
{
converter.ToXml(new Content(), "V1");
throw new Exception("Should be MappingException");
}
catch (MappingException ex)
{
Assert.AreEqual("Hello world", ex.Message);
}
}
public void ToXmlWrapsEngineException()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var engine = new Mock<IXmlMappingEngine>();
var converter = new XmlConverter(detector.Object, factory.Object);
factory.Setup(x => x.Find("V1")).Returns(engine.Object);
engine.Setup(x => x.CreateDocument(It.IsAny<Content>())).Throws(new ArgumentNullException());
// Act
try
{
converter.ToXml(new Content(), "V1");
throw new Exception("Should be MappingException");
}
catch (MappingException ex)
{
Assert.AreEqual("Could not convert entity to XML, version V1: Content", ex.Message);
Assert.IsInstanceOf(typeof(ArgumentNullException), ex.InnerException);
}
}
public void ToXmlWrapsEngineFactoryException()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
factory.Setup(x => x.Find("V1")).Throws<ArgumentNullException>();
// Act
try
{
converter.ToXml(new Content(), "V1");
throw new Exception("Should be MappingException");
}
catch (MappingException ex)
{
Assert.AreEqual("IXmlMappingEngine not found: V1", ex.Message);
Assert.IsInstanceOf<ArgumentNullException>(ex.InnerException);
}
}
private XMLChargeBandCalculator XmlChargeBandCalculator()
{
var xmlConverter = new XmlConverter(A.Fake<IWhiteSpaceCollapser>(), new Deserializer());
return new XMLChargeBandCalculator(xmlConverter, producerChargerCalculator);
}
public void ToXmlGeneratesXml()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var engine = new Mock<IXmlMappingEngine>();
var converter = new XmlConverter(detector.Object, factory.Object);
var element = new XElement("Test");
var expected = element.ToXmlString();
factory.Setup(x => x.Find("V1")).Returns(engine.Object);
engine.Setup(x => x.CreateDocument(It.IsAny<Content>())).Returns(element);
// Act
var candidate = converter.ToXml(new Content(), "V1");
// Assert
Assert.AreEqual(expected, candidate, "XML differs");
}
public void FromXmlWrapsInternalExceptions()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
detector.Setup(x => x.DetectSchemaVersion(It.IsAny<XElement>())).Throws<ArgumentNullException>();
// Act
try
{
converter.FromXml<Content>("<Test></Test>");
throw new Exception("Should be MappingException");
}
catch (MappingException ex)
{
// Don't bother checking actual error message - too fragile
Assert.IsInstanceOf<ArgumentNullException>(ex.InnerException);
}
}
public void ToXmlNullOnNullEntity()
{
// Arrange
// NOTE Strict mocks to ensure we're not called.
var detector = new Mock<IXmlVersionDetector>(MockBehavior.Strict);
var factory = new Mock<IXmlMappingEngineFactory>(MockBehavior.Strict);
var converter = new XmlConverter(detector.Object, factory.Object);
// Act
var candidate = converter.ToXml<Content>(null, "V1");
// Assert
Assert.IsNull(candidate);
}
public void ConvertNode(string input, string expected)
{
var sut = new XmlConverter();
var output = sut.Convert(input);
Assert.AreEqual(expected, output);
}
public void FromXmlFailOnUnregisteredEngineVersion()
{
// Arrange
var detector = new Mock<IXmlVersionDetector>();
var factory = new Mock<IXmlMappingEngineFactory>();
var converter = new XmlConverter(detector.Object, factory.Object);
detector.Setup(x => x.DetectSchemaVersion(It.IsAny<XElement>())).Returns("V1");
// Act
try
{
converter.FromXml<Content>("<Test></Test>");
throw new Exception("Should be MappingException");
}
catch (MappingException)
{
// Assert
// Don't bother checking actual error message - too fragile
// Ensure we asked for the correct version.
factory.Verify(x => x.Find("V1"));
}
}
public void Setup()
{
parserState = new XmlConverter(null, null);
}
/// <summary>
/// Invokes <see cref="XmlConverter.ToXml"/>.
/// </summary>
public static XmlDocument ToXml(this YamlDocument document, XmlConverterOptions options)
{
XmlConverter converter = new XmlConverter(options);
return converter.ToXml(document);
}
