private static void CreateLensIfNotExists(
PhotographyEntities context,
IEnumerable <XElement> xLenses,
Manufacturer manufacturer)
{
foreach (var xLense in xLenses)
{
// Find the lens by model and type (if exists)
var lenseModel = xLense.Attribute("model").Value;
var lenseType = xLense.Attribute("type").Value;
var lensePrice = xLense.Attribute("price");
var lens = context.Lenses.FirstOrDefault(l => l.Model == lenseModel);
if (lens != null)
{
Console.WriteLine($"Existing lens: {lenseModel}");
}
else
{
lens = new Lens
{
Model = lenseModel,
Type = lenseType,
Price = lensePrice != null?decimal.Parse(lensePrice.Value) : default(decimal?),
ManufacturerId = manufacturer.Id
};
context.Lenses.Add(lens);
context.SaveChanges();
Console.WriteLine("Created lens: {0}", lenseModel);
}
}
}
private static Manufacturer CreateManufacturerIfNotExist(PhotographyEntities context, XElement xManufacturer)
{
Manufacturer manufacturer = null;
var xElementManufacturerName = xManufacturer.Element("manufacturer-name");
if (xElementManufacturerName != null)
{
string manufacturerName = xElementManufacturerName.Value;
manufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == manufacturerName);
if (manufacturer != null)
{
Console.WriteLine($"Existing manufacturer: {manufacturerName}");
}
else
{
// Create a new manufacturer in the database
manufacturer = new Manufacturer()
{
Name = manufacturerName
};
context.Manufacturers.Add(manufacturer);
context.SaveChanges();
Console.WriteLine($"Created manufacturer: {manufacturerName}");
}
}
return(manufacturer);
}
static void Main(string[] args)
{
var context = new PhotographyEntities();
var photographs = context.Photographs
.OrderBy(p => p.Title)
.Select(p => new
{
p.Title,
category = p.Category.Name,
p.Link,
Equipment = new
{
Camera = new
{
Name = p.Equipment.Camera.Manufacturer.Name + " " + p.Equipment.Camera.Model,
Megapixels = p.Equipment.Camera.Megapixels
},
Lens = new
{
Model = p.Equipment.Lens.Manufacturer.Name + " " + p.Equipment.Lens.Model,
Price = p.Equipment.Lens.Price
}
}
});
var resultXml = new XElement("photographs");
foreach (var photo in photographs)
{
var photoXml = new XElement("photograph");
photoXml.Add(new XAttribute("title", photo.Title));
photoXml.Add(new XElement("category", photo.category));
photoXml.Add(new XElement("link", photo.Link));
var equipmentXml = new XElement("equipment");
equipmentXml.Add(new XElement("camera", photo.Equipment.Camera.Name, new XAttribute("megapixels", photo.Equipment.Camera.Megapixels)));
if (photo.Equipment.Lens.Price.HasValue)
{
equipmentXml.Add(new XElement("lens", photo.Equipment.Lens.Model, new XAttribute("price", string.Format("{0:f2}", photo.Equipment.Lens.Price))));
}
else
{
equipmentXml.Add(new XElement("lens", photo.Equipment.Lens.Model));
}
photoXml.Add(equipmentXml);
resultXml.Add(photoXml);
}
var resultXmlDoc = new XDocument();
resultXmlDoc.Add(resultXml);
resultXmlDoc.Save("photographs.xml");
Console.WriteLine("Photographs exported to photographs.xml");
}
private static XDocument CreateXDocument()
{
var context = new PhotographyEntities();
var photographs = context.Photographs
.Select(
ph => new
{
Title = ph.Title,
Category = ph.Category.Name,
Link = ph.Link,
Equipment = new
{
CameraModel = ph.Equipment.Camera.Model,
CameraMegapixels = ph.Equipment.Camera.Megapixels,
LensName = ph.Equipment.Lens.Model,
LensPrice = ph.Equipment.Lens.Price
}
})
.OrderBy(ph => ph.Title);
var photographsNode = new XElement("photographs");
foreach (var photograph in photographs)
{
var photographNode = new XElement(
"photograph",
new XAttribute("title", photograph.Title),
new XElement("category", photograph.Category),
new XElement("link", photograph.Link));
var equipmentNode = new XElement("equipment");
var cameraNode = new XElement("camera", photograph.Equipment.CameraModel);
if (photograph.Equipment.CameraMegapixels != null)
{
cameraNode.Add(new XAttribute("megapixels", photograph.Equipment.CameraMegapixels));
}
var lensNode = new XElement("lens", photograph.Equipment.LensName);
if (photograph.Equipment.LensPrice != null)
{
lensNode.Add(new XAttribute("price", photograph.Equipment.LensPrice));
}
equipmentNode.Add(cameraNode, lensNode);
photographNode.Add(equipmentNode);
photographsNode.Add(photographNode);
}
var xDocument = new XDocument(photographsNode);
return xDocument;
}
static void Main(string[] args)
{
var context = new PhotographyEntities();
var photosQuery = context.Photographs
.OrderBy(p => p.Title)
.Select(p => new
{
Title = p.Title,
Category = p.Category.Name,
Link = p.Link,
EquipmentCameras = p.Equipment.Camera,
EquipmentLens = p.Equipment.Lens,
});
var xmlDoc = new XDocument();
var xmlRoot = new XElement("photographs");
xmlDoc.Add(xmlRoot);
foreach (var photo in photosQuery)
{
var photoXML = new XElement("photograph", new XAttribute("title", photo.Title));
xmlRoot.Add(photoXML);
var categoryXML = new XElement("category", photo.Category);
var linkXml = new XElement("link", photo.Link);
photoXML.Add(categoryXML);
photoXML.Add(linkXml);
var equipmentXML = new XElement("equipment");
photoXML.Add(equipmentXML);
var cameraXML = new XElement("camera", photo.EquipmentCameras.Model, new XAttribute("megapixels", photo.EquipmentCameras.Megapixels));
equipmentXML.Add(cameraXML);
var lensXML = new XElement("lens", photo.EquipmentLens.Model);
if (photo.EquipmentLens.Price != null)
{
var attr = new XAttribute("price", photo.EquipmentLens.Price);
lensXML.Add(attr);
}
equipmentXML.Add(lensXML);
}
xmlDoc.Save(@"../../photographs.xml");
}
static void Main(string[] args)
{
var inputXml = XDocument.Load("../../manufacturers-and-lenses.xml");
var xManufacturers = inputXml.XPathSelectElements("/manufacturers-and-lenses/manufacturer");
var context = new PhotographyEntities();
int manufacturerCount = 1;
foreach (var xManufacturer in xManufacturers)
{
Console.WriteLine($"Processing manufacturer #{manufacturerCount}", ++manufacturerCount);
Manufacturer manufacturer = CreateManufacturerIfNotExist(context, xManufacturer);
var xLenses = xManufacturer.XPathSelectElements("lenses/lens");
CreateLensIfNotExists(context, xLenses, manufacturer);
Console.WriteLine();
}
}
public static void Main()
{
var context = new PhotographyEntities();
var cameras = context.Cameras
.Select(c => new
{
c.Model,
Manufactorer = c.Manufacturer.Name
})
.OrderBy(c => c.Manufactorer)
.ThenBy(c => c.Model);
foreach (var camera in cameras)
{
Console.WriteLine(camera.Manufactorer + ' ' + camera.Model);
}
}
private static Manufacturer ImportManufactorer(XElement manufacturerNode, PhotographyEntities context)
{
var manufactorerName = manufacturerNode.Element("manufacturer-name").Value;
var manufactorer = new Manufacturer();
if (!context.Manufacturers.Any(m => m.Name == manufactorerName))
{
manufactorer.Name = manufactorerName;
context.Manufacturers.Add(manufactorer);
Console.WriteLine("Created manufacturer: " + manufactorer.Name);
}
else
{
manufactorer = context.Manufacturers.FirstOrDefault(m => m.Name == manufactorerName);
if (manufactorer != null)
{
Console.WriteLine("Existing manufacturer: " + manufactorer.Name);
}
}
return manufactorer;
}
static void Main(string[] args)
{
var context = new PhotographyEntities();
var manufacturersQuery = context.Manufacturers
.OrderBy(m => m.Name)
.Select(m => new
{
manufacturer = m.Name,
cameras = m.Cameras
.OrderBy(c => c.Model)
.Select(c => new
{
model = c.Model,
price = c.Price
})
});
var json = new JavaScriptSerializer().Serialize(manufacturersQuery.ToList());
System.IO.File.WriteAllText(@"..\..\manufactureres-and-cameras.json", json);
}
public static void Main()
{
var context = new PhotographyEntities();
var manufactorers = context.Manufacturers
.Select(m => new
{
manufacturer = m.Name,
cameras = m.Cameras
.Select(c => new
{
model = c.Model,
price = c.Price
})
.OrderBy(c => c.model)
})
.OrderBy(m => m.manufacturer);
var output = JsonConvert.SerializeObject(manufactorers);
File.AppendAllText(@"..\..\manufactureres-and-cameras.json", output);
Console.WriteLine("Export manufactureres-and-cameras.json complited!");
}
static void Main(string[] args)
{
var context = new PhotographyEntities();
var manufacturers = context.Manufacturers
.OrderBy(m => m.Name)
.Select(m => new
{
m.Name,
cameras = m.Cameras
.OrderBy(c => c.Model)
.Select(c => new
{
c.Model,
c.Price
})
}).ToList();
var jsonSerializer = new JavaScriptSerializer();
var json = jsonSerializer.Serialize(manufacturers);
File.WriteAllText("manufactureres-and-cameras.json", json);
Console.WriteLine("manufactureres-and-cameras.json exported");
}
private static void ImportLenses(XElement manufacturerNode, PhotographyEntities context, Manufacturer manufactorer)
{
var lenses = manufacturerNode.XPathSelectElements("lenses/lens");
foreach (var lenseNode in lenses)
{
var lensModel = lenseNode.Attribute("model").Value;
var lens = new Lens();
if (!context.Lenses.Any(l => l.Model == lensModel))
{
lens.Model = lenseNode.Attribute("model").Value;
lens.Type = lenseNode.Attribute("type").Value;
if (lenseNode.Attribute("price") != null)
{
lens.Price = decimal.Parse(lenseNode.Attribute("price").Value);
}
context.Lenses.Add(lens);
if (manufactorer != null)
{
manufactorer.Lenses.Add(lens);
}
Console.WriteLine("Created lens: " + lens.Model);
}
else
{
lens = context.Lenses.FirstOrDefault(l => l.Model == lensModel);
if (lens != null)
{
Console.WriteLine("Existing lens: " + lens.Model);
}
}
}
}
public static void Main()
{
var context = new PhotographyEntities();
var xDocument = XDocument.Load(@"..\..\manufacturers-and-lenses.xml");
var manufacturersAndLenses = xDocument.XPathSelectElements("/manufacturers-and-lenses/manufacturer");
int count = 1;
foreach (var manufacturerNode in manufacturersAndLenses)
{
Console.WriteLine("Processing manufacturer #{0} ...", count);
var manufactorer = ImportManufactorer(manufacturerNode, context);
if (manufacturerNode.Element("lenses") != null)
{
ImportLenses(manufacturerNode, context, manufactorer);
}
context.SaveChanges();
count++;
}
}
private static void ProcessRequest(Request request)
{
var context = new PhotographyEntities();
var manufacturersQuery = context.Manufacturers.AsQueryable();
var manufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == request.ManufacturerName);
var cameraIds = context.Cameras
.Where(c => c.ManufacturerId == manufacturer.Id)
.Select(c => c.Id)
.ToList();
var lensIds = context.Lenses
.Where(l => l.ManufacturerId == manufacturer.Id)
.Select(l => l.Id)
.ToList();
var random = new Random();
for (int i = 0; i < request.GenerateCount; i++)
{
var equipment = new Equipment();
equipment.CameraId = cameraIds[random.Next(cameraIds.Count)];
equipment.LensId = lensIds[random.Next(lensIds.Count)];
context.Equipments.Add(equipment);
context.SaveChanges();
var equipmentDb = context.Equipments
.Include(x => x.Camera)
.Include(x => x.Lens)
.FirstOrDefault(x => x.Id == equipment.Id);
Console.WriteLine($"Equipment added: {manufacturer.Name} (Camera: {equipmentDb.Camera.Model} - Lens: {equipmentDb.Lens.Model})");
}
}
static void Main(string[] args)
{
var defaultGenerateCount = 10;
var context = new PhotographyEntities();
var defaultManufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == "Nikon");
var xmlDoc = XDocument.Load("../../generate-equipments.xml");
//var photographyElements = xmlDoc.Root.Elements();
var generateElements = xmlDoc.XPathSelectElements("/generate-random-equipments/generate");
var camerasIds = context.Cameras.Select(c => new { id = c.Id }).ToList();
var lensesIds = context.Lenses.Select(l => new { id = l.Id }).ToList();
var count = 1;
foreach (var element in generateElements)
{
Console.WriteLine("Processing request #{0} ...", count++);
var currentManufacturer = defaultManufacturer;
if (!string.IsNullOrEmpty(element.Value))
{
currentManufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == element.Value);
}
var currentGenerateCount = defaultGenerateCount;
if (element.HasAttributes)
{
currentGenerateCount = int.Parse(element.Attribute("generate-count").Value);
}
for (int i = 0; i < currentGenerateCount; i++)
{
var random = new Random();
var randomCameraId = camerasIds[random.Next(1, camerasIds.Count)];
var randomLensId = lensesIds[random.Next(1, lensesIds.Count)];
var camera = context.Cameras.FirstOrDefault(c => c.Id == randomCameraId.id);
var lens = context.Lenses.FirstOrDefault(c => c.Id == randomLensId.id);
Console.WriteLine(
"Equipment added: {0} (Camera: {1} - Lens: {2})",
currentManufacturer.Name,
camera.Model,
lens.Model);
if (!currentManufacturer.Cameras.Contains(camera))
{
currentManufacturer.Cameras.Add(camera);
}
if (!currentManufacturer.Lenses.Contains(lens))
{
currentManufacturer.Lenses.Add(lens);
}
}
context.SaveChanges();
Console.WriteLine();
}
Console.ReadLine();
}
static void Main(string[] args)
{
var context = new PhotographyEntities();
var xmlDoc = XDocument.Load("../../manufacturers-and-lenses.xml");
//var photographyElements = xmlDoc.Root.Elements();
var photographyElements = xmlDoc.XPathSelectElements("/manufacturers-and-lenses/manufacturer");
var count = 1;
foreach (var photographyElement in photographyElements)
{
Console.WriteLine("Processing manufacturer #{0} ...", count++);
var manufacturerName = photographyElement.Element("manufacturer-name").Value;
var manufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == manufacturerName);
if (manufacturer == null)
{
manufacturer = new Manufacturer();
manufacturer.Name = manufacturerName;
context.Manufacturers.Add(manufacturer);
Console.WriteLine("Created manufacturer: {0}", manufacturerName);
}
else
{
Console.WriteLine("Existing manufacturer: {0}", manufacturerName);
}
var lenses = photographyElement.XPathSelectElements("lenses/lens");
foreach (var lens in lenses)
{
var lensModel = lens.Attribute("model").Value;
var lensEntity = context.Lenses.FirstOrDefault(l => l.Model == lensModel);
if (lensEntity == null)
{
lensEntity = new Lens();
lensEntity.Model = lensModel;
var lensType = lens.Attribute("type").Value;
lensEntity.Type = lensType;
if (lens.Attribute("price") != null)
{
var lensPrice = lens.Attribute("price").Value;
lensEntity.Price = decimal.Parse(lensPrice);
}
context.Lenses.Add(lensEntity);
Console.WriteLine("Created lens {0}", lensModel);
}
else
{
Console.WriteLine("Existing lens: {0}", lensModel);
}
manufacturer.Lenses.Add(lensEntity);
}
context.SaveChanges();
Console.WriteLine();
}
}
