Exemple #1
0
        private List <MasterGroupMappingProduct> GetListOfMappedProductsBySourceMasterGroupMapping(MasterGroupMapping productGroup, List <VendorProductInfo> productsPerConnector)
        {
            List <MasterGroupMappingProduct> mappedProducts = new List <MasterGroupMappingProduct>();

            if (productGroup.SourceMasterGroupMappingID.HasValue && productGroup.SourceMasterGroupMappingID.Value > 0)
            {
                if (masterGroupMappingRepo.IsMasterGroupMappingExists(productGroup.SourceMasterGroupMappingID.Value))
                {
                    var currentProductsInMasterGroupMapping = masterGroupMappingRepo.GetListOfMappedProductsByMasterGroupMapping(productGroup.SourceMasterGroupMappingID.Value);

                    var mappedProductsInMasterGroupMapping =
                        (from p in productsPerConnector
                         join mp in currentProductsInMasterGroupMapping on p.ProductID equals mp.ProductID
                         select mp)
                        .ToList();

                    if (mappedProductsInMasterGroupMapping.Count > 0)
                    {
                        mappedProductsInMasterGroupMapping.ForEach(mappedProduct =>
                        {
                            MasterGroupMappingProduct toSyncMasterGroupMappingProduct = new MasterGroupMappingProduct()
                            {
                                MasterGroupMappingID       = productGroup.MasterGroupMappingID,
                                ProductID                  = mappedProduct.ProductID,
                                IsApproved                 = mappedProduct.IsApproved,
                                IsProductMapped            = true,
                                ConnectorPublicationRuleID = productsPerConnector.Where(x => x.ProductID == mappedProduct.ProductID).Select(x => x).FirstOrDefault().ConnectorPublicationRuleID
                            };
                            mappedProducts.Add(toSyncMasterGroupMappingProduct);
                        });
                    }
                }
            }
            return(mappedProducts);
        }
        public void FilterProductGroupByParent(List <MasterGroupMapping> listOfProductGroups)
        {
            listOfProductGroups.ForEach(productGroup => {
                List <Product> productsInProductGroup       = productRepo.GetListOfMappedProductsByMasterGroupMapping(productGroup.MasterGroupMappingID);
                List <Product> productsInParentProductGroup = productRepo.GetListOfMappedProductsByMasterGroupMapping(productGroup.ParentMasterGroupMappingID.Value);

                List <Product> productsToDelete = (
                    from p in productsInProductGroup
                    join pp in productsInParentProductGroup on p.ProductID equals pp.ProductID into notExistProducts
                    from nep in notExistProducts.DefaultIfEmpty()
                    where nep == null
                    select p
                    )
                                                  .ToList();

                productsToDelete.ForEach(product => {
                    MasterGroupMappingProduct newMasterGroupMappingProduct = new MasterGroupMappingProduct()
                    {
                        MasterGroupMappingID = productGroup.MasterGroupMappingID,
                        ProductID            = product.ProductID
                    };
                    masterGroupMappingRepo.DeleteMasterGroupMappingProduct(newMasterGroupMappingProduct);
                });
                log.DebugFormat("{0} Products Deleted From Product Group {1}", productsToDelete.Count, productGroup.MasterGroupMappingID);
            });
        }
Exemple #3
0
   public void UpdateMasterGroupMappingIDOfMasterGroupMappingProduct(MasterGroupMappingProduct masterGroupMappingProduct, int masterGroupMappingID)
   {
       petaPoco.Update <MasterGroupMappingProduct>(string.Format(@"
   SET MasterGroupMappingID = {0}
   WHERE MasterGroupMappingID = {1} AND ProductID = {2}
 ", masterGroupMappingID, masterGroupMappingProduct.MasterGroupMappingID, masterGroupMappingProduct.ProductID));
   }
Exemple #4
0
        public MasterGroupMappingProduct GetMasterGroupMappingProductByID(int masterGroupMappingID, int productID)
        {
            MasterGroupMappingProduct masterGroupMappingProduct = petaPoco.SingleOrDefault <MasterGroupMappingProduct>(string.Format(@"
        SELECT *
        FROM MasterGroupMappingProduct
        WHERE MasterGroupMappingID = {0}
	        AND ProductID = {1}
      ", masterGroupMappingID, productID));

            return(masterGroupMappingProduct);
        }
Exemple #5
0
 public void InsertMasterGroupMappingProduct(int masterGroupMappingID, MasterGroupMappingProduct masterGroupMappingProduct)
 {
     petaPoco.Insert("MasterGroupMappingProduct", "MasterGroupMappingID, ProductID", false,
                     new
     {
         MasterGroupMappingID       = masterGroupMappingID,
         ProductID                  = masterGroupMappingProduct.ProductID,
         IsApproved                 = masterGroupMappingProduct.IsApproved,
         IsProductMapped            = masterGroupMappingProduct.IsProductMapped,
         ConnectorPublicationRuleID = masterGroupMappingProduct.ConnectorPublicationRuleID
     });
 }
Exemple #6
0
        public void UpdateMasterGroupMappingProduct(MasterGroupMappingProduct masterGroupMappingProduct)
        {
            MasterGroupMappingProduct currentMasterGroupMappingProduct = GetMasterGroupMappingProductByID(masterGroupMappingProduct.MasterGroupMappingID, masterGroupMappingProduct.ProductID);

            StringBuilder changes = new StringBuilder();

            List <string> listOfChanges = generateUpdateFields.GetPropertiesForUpdate(masterGroupMappingProduct, currentMasterGroupMappingProduct);

            if (masterGroupMappingProduct.IsApproved != currentMasterGroupMappingProduct.IsApproved)
            {
                changes.Append(string.Format("IsApproved = {0}", (masterGroupMappingProduct.IsApproved ? 1 : 0)));
            }

            if (masterGroupMappingProduct.IsCustom != currentMasterGroupMappingProduct.IsCustom)
            {
                if (!string.IsNullOrEmpty(changes.ToString()))
                {
                    changes.Append(",");
                }
                changes.Append(string.Format("IsCustom = {0}", (masterGroupMappingProduct.IsCustom ? 1 : 0)));
            }

            if (masterGroupMappingProduct.IsProductMapped != currentMasterGroupMappingProduct.IsProductMapped)
            {
                if (!string.IsNullOrEmpty(changes.ToString()))
                {
                    changes.Append(",");
                }
                changes.Append(string.Format("IsProductMapped = {0}", (masterGroupMappingProduct.IsProductMapped ? 1 : 0)));
            }

            if (masterGroupMappingProduct.ConnectorPublicationRuleID.HasValue && masterGroupMappingProduct.ConnectorPublicationRuleID.Value > 0)
            {
                if ((!currentMasterGroupMappingProduct.ConnectorPublicationRuleID.HasValue) || masterGroupMappingProduct.ConnectorPublicationRuleID.Value != currentMasterGroupMappingProduct.ConnectorPublicationRuleID.Value)
                {
                    if (!string.IsNullOrEmpty(changes.ToString()))
                    {
                        changes.Append(",");
                    }
                    changes.Append(string.Format("ConnectorPublicationRuleID = {0}", masterGroupMappingProduct.ConnectorPublicationRuleID.Value));
                }
            }

            if (!string.IsNullOrEmpty(changes.ToString()))
            {
                petaPoco.Update <MasterGroupMappingProduct>(string.Format(@"
          SET {2}
          WHERE MasterGroupMappingID = {0}
	          AND ProductID = {1}
        ", masterGroupMappingProduct.MasterGroupMappingID, masterGroupMappingProduct.ProductID, changes));
            }
        }
Exemple #7
0
        public void Process()
        {
            var connectorID = (_connector.ParentConnectorID.HasValue ? _connector.ParentConnectorID.Value : _connector.ConnectorID);
            var score       = 0;

            Dictionary <int, bool> existingCPGs = _repoContentProductGroup.GetAll(c => c.ConnectorID == _connector.ConnectorID && c.IsCustom && c.MasterGroupMappingID != null).Select(c => c.ContentProductGroupID).Select(c => new { ContentProductGroupID = c, Active = false }).ToDictionary(c => c.ContentProductGroupID, c => c.Active);
            List <string>          allMasterGroupMappingBackendLabels = _repoMasterGroupMapping.GetAll(c => c.ConnectorID == _connector.ConnectorID && c.BackendMatchingLabel != null).Select(c => c.BackendMatchingLabel).ToList().Where(c => !string.IsNullOrEmpty(c)).ToList();

            foreach (var grp in _groups)
            {
                var parentMasterGroupMapping = _repoMasterGroupMapping.GetAll(c => c.ConnectorID == connectorID && c.ProductGroupID == _getTheLookGroupID).Where(c => c.MasterGroupMappingParent.ProductGroup.ProductGroupVendors.FirstOrDefault(l => l.VendorID == 1).VendorProductGroupCode1 == grp.TargetGroup).FirstOrDefault();

                if (parentMasterGroupMapping == null)
                {
                    continue;
                }

                var label   = grp.BackendLabel;
                var mapping = _repoMasterGroupMapping.GetSingle(c => c.ProductGroupID == _groupID && c.BackendMatchingLabel == label && c.ParentMasterGroupMappingID == parentMasterGroupMapping.MasterGroupMappingID);

                allMasterGroupMappingBackendLabels.Remove(label);

                if (mapping == null)
                {
                    mapping = new MasterGroupMapping()
                    {
                        CustomProductGroupLabel    = label,
                        ProductGroupID             = _groupID,
                        ConnectorID                = connectorID,
                        MasterGroupMappingParent   = parentMasterGroupMapping,
                        ParentMasterGroupMappingID = parentMasterGroupMapping.MasterGroupMappingID,
                        BackendMatchingLabel       = label,
                        Score = score,
                        MasterGroupMappingProducts = new List <MasterGroupMappingProduct>()
                    };

                    var magentoProductGroupSetting = new MagentoProductGroupSetting()
                    {
                        MasterGroupMapping = mapping,
                        DisabledMenu       = true,
                        ShowInMenu         = true
                    };

                    _repoMasterGroupMapping.Add(mapping);
                    _repoMagentoSetting.Add(magentoProductGroupSetting);
                }

                foreach (var prod in grp.Products)
                {
                    var activeCPG = _repoContentProductGroup.GetSingle(c =>
                                                                       c.ProductID == prod &&
                                                                       c.ConnectorID == _connector.ConnectorID &&
                                                                       c.IsCustom &&
                                                                       c.MasterGroupMapping.BackendMatchingLabel == mapping.BackendMatchingLabel &&
                                                                       c.MasterGroupMapping.ParentMasterGroupMappingID == mapping.ParentMasterGroupMappingID);

                    if (activeCPG == null)
                    {
                        var content = _repoContent.GetSingle(c => c.ProductID == prod && c.ConnectorID == _connector.ConnectorID);
                        if (content != null)
                        {
                            activeCPG = new ContentProductGroup()
                            {
                                ProductID             = prod,
                                ConnectorID           = _connector.ConnectorID,
                                IsCustom              = true,
                                MasterGroupMapping    = mapping,
                                ProductGroupMappingID = 933 //TODO: for now hardcoded, remove when total migration is complete
                            };
                            _repoContentProductGroup.Add(activeCPG);

                            var masterGroupMappingProduct = mapping.MasterGroupMappingProducts.FirstOrDefault(x => x.ProductID == prod);

                            if (masterGroupMappingProduct == null)
                            {
                                masterGroupMappingProduct = new MasterGroupMappingProduct()
                                {
                                    ProductID = prod,
                                    IsCustom  = true
                                };

                                mapping.MasterGroupMappingProducts.Add(masterGroupMappingProduct);
                            }
                        }
                    }
                    else
                    {
                        existingCPGs[activeCPG.ContentProductGroupID] = true;
                    }
                }
                score++;
            }

            foreach (var cp in existingCPGs.Where(c => !c.Value))
            {
                var contentProductGroup = _repoContentProductGroup.GetSingle(c => c.ContentProductGroupID == cp.Key);
                if (contentProductGroup.CreatedBy == 1) ///quick fix
                {
                    _repoContentProductGroup.Delete(contentProductGroup);
                }
            }
        }
Exemple #8
0
 public void DeleteMasterGroupMappingProduct(MasterGroupMappingProduct masterGroupMappingProduct)
 {
     petaPoco.Delete("MasterGroupMappingProduct", "MasterGroupMappingID, ProductID", masterGroupMappingProduct);
 }