Ejemplo n.º 1
0
        public static string ImportCategories(ProductShopContext context, string inputJson)
        {
            var categoryProducts = new List <CategoryProduct>();

            categoryProducts = JsonConvert.DeserializeObject <List <CategoryProduct> >(inputJson);

            context.AddRange(categoryProducts.Select(x => x.Product.Seller)
                             .Where(x => x.FirstName != null && x.LastName != null));

            context.AddRange(categoryProducts.Select(x => x.Product.Buyer)
                             .Where(x => x.FirstName != null && x.LastName != null));

            return($"Successfully imported {categoryProducts.Count}");
        }
Ejemplo n.º 2
0
        public static string ImportUsers(ProductShopContext context, string inputXml)
        {
            var serializer = new XmlSerializer(typeof(UserDto[]),
                                               new XmlRootAttribute("Users"));

            UserDto[] userDtos;

            using (var reader = new StringReader(inputXml))
            {
                userDtos = (UserDto[])serializer.Deserialize(reader);
            }

            var users = userDtos
                        .Select(u => new User
            {
                FirstName = u.FirstName,
                LastName  = u.LastName,
                Age       = u.Age
            })
                        .ToArray();

            context.AddRange(users);
            context.SaveChanges();

            return($"Successfully imported {users.Length}");
        }
Ejemplo n.º 3
0
        public static string ImportCategories(ProductShopContext context, string inputXml)
        {
            var xmlSerializar = new XmlSerializer(typeof(ImportCategoriesDTO[]), new XmlRootAttribute("Categories"));

            ImportCategoriesDTO[] importCategoriesDTOs;

            using (var reader = new StringReader(inputXml))
            {
                importCategoriesDTOs = (ImportCategoriesDTO[])xmlSerializar.Deserialize(reader);
            }

            var categories = Mapper.Map <Category[]>(importCategoriesDTOs);

            var end = new List <Category>();

            foreach (var category in categories)
            {
                if (string.IsNullOrEmpty(category.Name))
                {
                    continue;
                }
                end.Add(category);
            }

            context.AddRange(end);
            context.SaveChanges();

            return($"Successfully imported {end.Count}");
        }
Ejemplo n.º 4
0
        public static string ImportCategoryProducts(ProductShopContext context, string inputXml)
        {
            var serializer = new XmlSerializer(typeof(List <ImportCategoryProductDto>), new XmlRootAttribute("CategoryProducts"));

            var categoryProductsDto = (List <ImportCategoryProductDto>)serializer.Deserialize(new StringReader(inputXml));

            var categoryProducts = new List <CategoryProduct>();

            var categories = context.Categories.Select(x => x.Id).ToList();

            var products = context.Products.Select(x => x.Id).ToList();

            foreach (var importCategoryProductDto in categoryProductsDto)
            {
                var categoryProduct = Mapper.Map <CategoryProduct>(importCategoryProductDto);

                if (categories.Contains(categoryProduct.CategoryId) && products.Contains(categoryProduct.ProductId))
                {
                    categoryProducts.Add(categoryProduct);
                }
            }

            context.AddRange(categoryProducts);
            context.SaveChanges();

            return(string.Format(Result, categoryProducts.Count));
        }
Ejemplo n.º 5
0
        public static string ImportProducts(ProductShopContext context, string inputXml)
        {
            var serializer = new XmlSerializer(typeof(ProductDto[]),
                                               new XmlRootAttribute("Products"));

            ProductDto[] productDtos;

            using (var reader = new StringReader(inputXml))
            {
                productDtos = (ProductDto[])serializer.Deserialize(reader);
            }

            var products = productDtos
                           .Select(p => new Product
            {
                Name     = p.Name,
                Price    = p.Price,
                SellerId = p.SellerId,
                BuyerId  = p.BuyerId
            })
                           .ToArray();

            context.AddRange(products);
            context.SaveChanges();

            return($"Successfully imported {products.Length}");
        }
Ejemplo n.º 6
0
        public static string ImportCategoryProducts(ProductShopContext context, string inputXml) // Query 4. Import Categories and Products
        {
            var root = "CategoryProducts";

            var categorys = context.Categories.Select(c => c.Id).ToArray();
            var products  = context.Products.Select(p => p.Id).ToArray();

            var categoryProductDto = XmlConverter.Deserializer <CategoryProductInputModel>(inputXml, root);

            var categoryProduct = categoryProductDto
                                  .Where(cp => categorys.Contains(cp.CategoryId) && products.Contains(cp.ProductId))
                                  .Select(cp => new CategoryProduct
            {
                CategoryId = cp.CategoryId,
                ProductId  = cp.ProductId
            })
                                  .ToList();

            context.AddRange(categoryProduct);
            context.SaveChanges();

            var result = $"Successfully imported {categoryProduct.Count}";

            return(result);
        }
Ejemplo n.º 7
0
        public static string ImportUsers(ProductShopContext context, string inputXml)
        {
            var xmlSerializer = new XmlSerializer(typeof(UserInputModel[]), new XmlRootAttribute("Users"));

            var usersDtos = (UserInputModel[])xmlSerializer.Deserialize(new StringReader(inputXml));

            var users = new List <User>();

            foreach (var userDto in usersDtos)
            {
                User user = new User()
                {
                    FirstName = userDto.FirstName,
                    LastName  = userDto.LastName,
                    Age       = userDto.Age
                };

                users.Add(user);
            }

            context.AddRange(users);
            context.SaveChanges();

            return($"Successfully imported {users.Count}");
        }
Ejemplo n.º 8
0
        //Imports
        public static string ImportUsers(ProductShopContext context, string inputXml)
        {
            XDocument xdoc = XDocument.Load(inputXml);

            List <XElement> elements = xdoc.Root.Elements().ToList();

            IList <User> users = new List <User>();

            elements.ForEach(element =>
            {
                User user = new User()
                {
                    FirstName = element.Element("firstName").Value,
                    LastName  = element.Element("lastName").Value,
                    Age       = (int?)int.Parse(element.Element("age").Value)
                };

                users.Add(user);
            });

            context.AddRange(users);
            int affectedRows = context.SaveChanges();

            return($"Successfully imported {affectedRows}");
        }
Ejemplo n.º 9
0
 //Problem 3
 public static string ImportCategories(ProductShopContext context, string inputJson)
 {
     Category[] categories = JsonConvert.DeserializeObject <Category[]>(inputJson).Where(x => x.Name != null).ToArray();
     context.AddRange(categories);
     context.SaveChanges();
     return($"Successfully imported {categories.Length}");
 }
Ejemplo n.º 10
0
        public static string ImportProducts(ProductShopContext context, string inputXml)
        {
            var xmlSerializer = new XmlSerializer(typeof(ProductInputModel[])
                                                  , new XmlRootAttribute("Products"));

            var productDtos = (ProductInputModel[])xmlSerializer.Deserialize(new StringReader(inputXml));

            var products = new List <Product>();

            foreach (var productDto in productDtos)
            {
                Product product = new Product()
                {
                    Name     = productDto.Name,
                    Price    = productDto.Price,
                    SellerId = productDto.SellerId,
                    BuyerId  = productDto.BuyerId
                };

                products.Add(product);
            }


            context.AddRange(products);
            context.SaveChanges();

            return($"Successfully imported {products.Count}");
        }
Ejemplo n.º 11
0
 //Problem 4
 public static string ImportCategoryProducts(ProductShopContext context, string inputJson)
 {
     CategoryProduct[] categoriProducts = JsonConvert.DeserializeObject <CategoryProduct[]>(inputJson);
     context.AddRange(categoriProducts);
     context.SaveChanges();
     return($"Successfully imported {categoriProducts.Length}");
 }
        //04. Import Categories and Products
        public static string ImportCategoryProducts(ProductShopContext context, string inputJson)
        {
            var categoryIds = context.Categories.Select(x => x.Id).ToList();

            var productIds = context.Products.Select(x => x.Id).ToList();

            var desCategoryProducts = JsonConvert.DeserializeObject <CategoryProduct[]>(inputJson);

            var validCategoryProducts = new List <CategoryProduct>();

            foreach (var categoryProduct in desCategoryProducts)
            {
                validCategoryProducts.Add(categoryProduct);
                //!!!Skip Validation - Judge is not accepting it!!!
                //if (categoryIds.Contains(categoryProduct.CategoryId) && productIds.Contains(categoryProduct.ProductId))
                //{
                //    validCategoryProducts.Add(categoryProduct);
                //}
            }
            context.AddRange(validCategoryProducts);

            context.SaveChanges();

            return($"Successfully imported {validCategoryProducts.Count}");
        }
Ejemplo n.º 13
0
 //Problem 1
 public static string ImportUsers(ProductShopContext context, string inputJson)
 {
     User[] users = JsonConvert.DeserializeObject <User[]>(inputJson);
     context.AddRange(users);
     context.SaveChanges();
     return($"Successfully imported {users.Length}");
 }
Ejemplo n.º 14
0
        public static string ImportCategoryProducts(ProductShopContext context, string inputXml)
        {
            var xmlSerializer = new XmlSerializer(typeof(CategoryProductInputModel[]),
                                                  new XmlRootAttribute("CategoryProducts"));
            var categoryProductsDtos = (CategoryProductInputModel[])xmlSerializer.Deserialize
                                           (new StringReader(inputXml));
            var categoriesProducts = new List <CategoryProduct>();

            foreach (var cpDto in categoryProductsDtos)
            {
                var categoryProduct = new CategoryProduct()
                {
                    CategoryId = cpDto.CategoryId,
                    ProductId  = cpDto.ProductId
                };

                categoriesProducts.Add(categoryProduct);
            }



            context.AddRange(categoriesProducts);
            context.SaveChanges();

            return($"Successfully imported {categoriesProducts.Count}");
        }
Ejemplo n.º 15
0
        public static string ImportCategoryProducts(ProductShopContext context, string inputXml)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(CategoryProductDto[]), new XmlRootAttribute("CategoryProducts"));


            CategoryProductDto[] seriaizedCategoryProducts;

            using (var reader = new StringReader(inputXml))
            {
                seriaizedCategoryProducts = (CategoryProductDto[])serializer.Deserialize(reader);
            }

            var productsIds   = context.Products.Select(x => x.Id);
            var categoriesIds = context.Categories.Select(x => x.Id);

            var categoryProducts = seriaizedCategoryProducts
                                   .Where(x => productsIds.Contains(x.ProductId) && categoriesIds.Contains(x.CategoryId))
                                   .Select(x => new CategoryProduct
            {
                ProductId  = x.ProductId,
                CategoryId = x.CategoryId
            })
                                   .ToArray();

            context.AddRange(categoryProducts);
            context.SaveChanges();

            return($"Successfully imported {categoryProducts.Length}");
        }
Ejemplo n.º 16
0
        public static string ImportCategories(ProductShopContext context, string inputXml)
        {
            var xmlSerializer = new XmlSerializer(typeof(CategoryDTO[]), new XmlRootAttribute("Categories"));

            var categoriesDto = (CategoryDTO[])xmlSerializer.Deserialize(new StringReader(inputXml));

            //var categories = Mapper.Map<Category[]>(categoriesDto);

            var categories = new List <Category>();

            foreach (var categoryDto in categoriesDto)
            {
                if (categoryDto.Name != null)
                {
                    categories.Add(new Category()
                    {
                        Name = categoryDto.Name,
                    });
                }
            }

            context.AddRange(categories);
            context.SaveChanges();

            return($"Successfully imported {categories.Count}");
        }
Ejemplo n.º 17
0
        public static string ImportProducts(ProductShopContext context, string inputJson)
        {
            List <Product> validProducts = JsonConvert.DeserializeObject <List <Product> >(inputJson).Where(x => x.Name.Length >= 3 || x.Name != null).ToList();

            context.AddRange(validProducts);
            context.SaveChanges();

            return($"Successfully imported {validProducts.Count}");
        }
Ejemplo n.º 18
0
        //Problem02
        public static string ImportProducts(ProductShopContext context, string inputJson)
        {
            List <Product> products = JsonConvert.DeserializeObject <List <Product> >(inputJson);

            context.AddRange(products);
            context.SaveChanges();

            return($"Successfully imported {products.Count}");
        }
Ejemplo n.º 19
0
        public static string ImportCategoryProducts(ProductShopContext context, string inputJson)
        {
            CategoryProduct[] validCatProd = JsonConvert.DeserializeObject <CategoryProduct[]>(inputJson).ToArray();

            context.AddRange(validCatProd);
            context.SaveChanges();

            return($"Successfully imported {validCatProd.Length}");
        }
Ejemplo n.º 20
0
        public static string ImportCategories(ProductShopContext context, string inputJson)
        {
            List <Category> validCategory = JsonConvert.DeserializeObject <List <Category> >(inputJson).Where(x => !string.IsNullOrEmpty(x.Name) && x.Name.Count() >= 3 && x.Name.Count() <= 15).ToList();

            context.AddRange(validCategory);
            context.SaveChanges();

            return($"Successfully imported {validCategory.Count}");
        }
Ejemplo n.º 21
0
        }//01

        public static string ImportProducts(ProductShopContext context, string inputJson)
        {
            var products = JsonConvert.DeserializeObject <Product[]>(inputJson);

            context.AddRange(products);
            context.SaveChanges();

            return($"Successfully imported {products.Length}");
        }//02
Ejemplo n.º 22
0
        //Query 5.Import Categories and Products
        public static string ImportCategoryProducts(ProductShopContext context, string inputJson)
        {
            var categoriesAndProducts = JsonConvert.DeserializeObject <List <CategoryProduct> >(inputJson);

            context.AddRange(categoriesAndProducts);
            context.SaveChanges();

            return($"Successfully imported {categoriesAndProducts.Count}");
        }
Ejemplo n.º 23
0
        public static string ImportUsers(ProductShopContext context, string inputJson)
        {
            User[] validUsers = JsonConvert.DeserializeObject <User[]>(inputJson).Where(x => x.LastName.Length >= 3 || x.LastName != null).ToArray();

            context.AddRange(validUsers);
            context.SaveChanges();

            return($"Successfully imported {validUsers.Length}");
        }
Ejemplo n.º 24
0
        //EXERCISE 1 - Import Users
        public static string ImportUsers(ProductShopContext context, string inputJson)
        {
            var users = JsonConvert.DeserializeObject <List <User> >(inputJson);
            var deserializedUsersCount = users.Count;

            context.AddRange(users);
            context.SaveChanges();
            return($"Successfully imported {deserializedUsersCount}");
        }
Ejemplo n.º 25
0
        //Problem 3.
        public static string ImportCategories(ProductShopContext context, string inputJson)
        {
            var categories = JsonConvert.DeserializeObject <Category[]>(inputJson)
                             .Where(c => c.Name != null);

            context.AddRange(categories);
            var count = context.SaveChanges();

            return($"Successfully imported {count}");
        }
Ejemplo n.º 26
0
        public static string ImportCategories(ProductShopContext context, string inputJson)
        {
            var categories = JsonConvert.DeserializeObject <List <Category> >(inputJson);

            categories.RemoveAll(x => x.Name == null);
            context.AddRange(categories);
            context.SaveChanges();

            return($"Successfully imported {categories.Count}");
        }
        public static string ImportUsers(ProductShopContext context, string inputJson)
        {
            InitializeMapper();
            var users         = JsonConvert.DeserializeObject <IEnumerable <UserJsonModel> >(inputJson);
            var usersComplete = mapper.Map <IEnumerable <User> >(users);

            context.AddRange(usersComplete);
            context.SaveChanges();
            return($"Successfully imported {usersComplete.Count()}");
        }
Ejemplo n.º 28
0
        public static string ImportCategoryProducts(ProductShopContext context, string inputJson)
        {
            var catProd = JsonConvert.DeserializeObject <CategoryProduct[]>(inputJson);
            int count   = catProd.Length;

            context.AddRange(catProd);
            context.SaveChanges();

            return($"Successfully imported {count}");
        }
Ejemplo n.º 29
0
        public static string ImportProducts(ProductShopContext db, string inputJson)
        {
            var productDTO = JsonConvert.DeserializeObject <List <ImportProductDTO> >(inputJson);

            var products = mapper.Map <List <Product> >(productDTO);

            db.AddRange(products);
            db.SaveChanges();

            return($"Successfully imported {products.Count}");
        }
        public static string ImportProducts(ProductShopContext context, string inputJson)
        {
            Product[] products = JsonConvert.DeserializeObject <Product[]>(inputJson)
                                 .Where(p => !string.IsNullOrEmpty(p.Name) && p.Name.Length >= 3)
                                 .ToArray();

            context.AddRange(products);
            context.SaveChanges();

            return($"Successfully imported {products.Length}");
        }