private void ExecAttributeImage(Model.Prestashop.PsImage PsImage, Model.Local.ArticleImage ArticleImage)
        {
            Model.Prestashop.PsProductAttributeImageRepository PsProductAttributeImageRepository = new Model.Prestashop.PsProductAttributeImageRepository();
            List <Model.Prestashop.PsProductAttributeImage>    ListPsProductAttributeImage       = PsProductAttributeImageRepository.ListImage(PsImage.IDImage);

            Model.Local.AttributeArticleImageRepository   AttributeArticleImageRepository   = new Model.Local.AttributeArticleImageRepository();
            Model.Local.CompositionArticleImageRepository CompositionArticleImageRepository = new Model.Local.CompositionArticleImageRepository();
            Model.Local.AttributeArticleRepository        AttributeArticleRepository        = new Model.Local.AttributeArticleRepository();
            Model.Local.CompositionArticleRepository      CompositionArticleRepository      = new Model.Local.CompositionArticleRepository();

            #region suppression lien image déclinaison
            List <Model.Local.AttributeArticleImage>   ListAttributeArticleImage   = AttributeArticleImageRepository.ListImageArticle(ArticleImage.ImaArt_Id);
            List <Model.Local.CompositionArticleImage> ListCompositionArticleImage = CompositionArticleImageRepository.ListImageArticle(ArticleImage.ImaArt_Id);

            Model.Prestashop.PsProductAttributeRepository PsProductAttributeRepository = new Model.Prestashop.PsProductAttributeRepository();
            // liste des liens images déclinaisons PrestaConnect
            foreach (Model.Local.AttributeArticleImage AttributeArticleImage in ListAttributeArticleImage)
            {
                // si la déclinaison PrestaConnectexiste dans PrestaConnect
                if (AttributeArticleRepository.Exist(AttributeArticleImage.AttArt_Id))
                {
                    Model.Local.AttributeArticle AttributeArticle = AttributeArticleRepository.Read(AttributeArticleImage.AttArt_Id);
                    if (AttributeArticle.Pre_Id != null && AttributeArticle.Pre_Id != 0)
                    {
                        // si dans PrestaShop la déclinaison n'est pas liée à l'image
                        if (ListPsProductAttributeImage.Count(pai => pai.IDProductAttribute == (uint)AttributeArticle.Pre_Id.Value) == 0)
                        {
                            // suppression du lien dans PrestaConnect
                            AttributeArticleImageRepository.Delete(AttributeArticleImage);
                        }
                    }
                }
            }
            foreach (Model.Local.CompositionArticleImage CompositionArticleImage in ListCompositionArticleImage)
            {
                if (CompositionArticleRepository.Exist(CompositionArticleImage.ComArt_Id))
                {
                    Model.Local.CompositionArticle CompositionArticle = CompositionArticleRepository.Read(CompositionArticleImage.ComArt_Id);
                    if (CompositionArticle.Pre_Id != null && CompositionArticle.Pre_Id != 0)
                    {
                        // si dans PrestaShop la déclinaison n'est pas liée à l'image
                        if (ListPsProductAttributeImage.Count(pai => pai.IDProductAttribute == (uint)CompositionArticle.Pre_Id.Value) == 0)
                        {
                            // suppression du lien dans PrestaConnect
                            CompositionArticleImageRepository.Delete(CompositionArticleImage);
                        }
                    }
                }
            }
            #endregion

            foreach (Model.Prestashop.PsProductAttributeImage PsProductAttributeImage in ListPsProductAttributeImage)
            {
                if (AttributeArticleRepository.ExistPrestashop((int)PsProductAttributeImage.IDProductAttribute))
                {
                    Model.Local.AttributeArticle AttributeArticle = AttributeArticleRepository.ReadPrestashop((int)PsProductAttributeImage.IDProductAttribute);
                    if (!AttributeArticleImageRepository.ExistAttributeArticleImage(AttributeArticle.AttArt_Id, ArticleImage.ImaArt_Id))
                    {
                        AttributeArticleImageRepository.Add(new Model.Local.AttributeArticleImage()
                        {
                            AttArt_Id = AttributeArticle.AttArt_Id,
                            ImaArt_Id = ArticleImage.ImaArt_Id,
                        });
                    }
                }
                else if (CompositionArticleRepository.ExistPrestaShop((int)PsProductAttributeImage.IDProductAttribute))
                {
                    Model.Local.CompositionArticle CompositionArticle = CompositionArticleRepository.ReadPrestaShop((int)PsProductAttributeImage.IDProductAttribute);
                    if (!AttributeArticleImageRepository.ExistAttributeArticleImage(CompositionArticle.ComArt_Id, ArticleImage.ImaArt_Id))
                    {
                        CompositionArticleImageRepository.Add(new Model.Local.CompositionArticleImage()
                        {
                            ComArt_Id = CompositionArticle.ComArt_Id,
                            ImaArt_Id = ArticleImage.ImaArt_Id,
                        });
                    }
                }
            }
        }
        private void ExecAttributeImage(Model.Local.Article Article)
        {
            Model.Local.ArticleImageRepository ArticleImageRepository = new Model.Local.ArticleImageRepository();
            List <Model.Local.ArticleImage>    ListArticleImage       = ArticleImageRepository.ListArticle(Article.Art_Id);

            Model.Local.AttributeArticleImageRepository        AttributeArticleImageRepository   = new Model.Local.AttributeArticleImageRepository();
            Model.Local.CompositionArticleImageRepository      CompositionArticleImageRepository = new Model.Local.CompositionArticleImageRepository();
            Model.Prestashop.PsProductAttributeImageRepository PsProductAttributeImageRepository = new Model.Prestashop.PsProductAttributeImageRepository();
            Model.Prestashop.PsImageRepository PsImageRepository  = new Model.Prestashop.PsImageRepository();
            Model.Local.AttributeArticle       AttributeArticle   = new Model.Local.AttributeArticle();
            Model.Local.CompositionArticle     CompositionArticle = new Model.Local.CompositionArticle();

            foreach (Model.Local.ArticleImage ArticleImage in ListArticleImage)
            {
                if (ArticleImage.Pre_Id != null && PsImageRepository.ExistImage((uint)ArticleImage.Pre_Id.Value))
                {
                    List <Model.Local.AttributeArticleImage>   ListAttributeArticleImage   = AttributeArticleImageRepository.ListImageArticle(ArticleImage.ImaArt_Id);
                    List <Model.Local.CompositionArticleImage> ListCompositionArticleImage = CompositionArticleImageRepository.ListImageArticle(ArticleImage.ImaArt_Id);

                    #region suppression lien image déclinaison PrestaShop
                    Model.Local.AttributeArticleRepository   AttributeArticleRepository   = new Model.Local.AttributeArticleRepository();
                    Model.Local.CompositionArticleRepository CompositionArticleRepository = new Model.Local.CompositionArticleRepository();
                    // liste des liens images déclinaisons Prestashop
                    foreach (Model.Prestashop.PsProductAttributeImage PsProductAttributeImage in PsProductAttributeImageRepository.ListImage((uint)ArticleImage.Pre_Id))
                    {
                        // si la déclinaison existe dans PrestaConnect
                        if (AttributeArticleRepository.ExistPrestashop((int)PsProductAttributeImage.IDProductAttribute))
                        {
                            AttributeArticle = AttributeArticleRepository.ReadPrestashop((int)PsProductAttributeImage.IDProductAttribute);
                            // si dans prestaconnect la déclinaison n'est pas liée à l'image
                            if (!AttributeArticleImageRepository.ExistAttributeArticleImage(AttributeArticle.AttArt_Id, ArticleImage.ImaArt_Id))
                            {
                                // suppression du lien dans PrestaShop
                                PsProductAttributeImageRepository.Delete(PsProductAttributeImage);
                            }
                        }
                        else if (CompositionArticleRepository.ExistPrestaShop((int)PsProductAttributeImage.IDProductAttribute))
                        {
                            CompositionArticle = CompositionArticleRepository.ReadPrestaShop((int)PsProductAttributeImage.IDProductAttribute);
                            // si dans prestaconnect la déclinaison n'est pas liée à l'image
                            if (!CompositionArticleImageRepository.ExistCompositionArticleImage(CompositionArticle.ComArt_Id, ArticleImage.ImaArt_Id))
                            {
                                // suppression du lien dans PrestaShop
                                PsProductAttributeImageRepository.Delete(PsProductAttributeImage);
                            }
                        }
                    }
                    #endregion

                    // affectation image déclinaison
                    foreach (Model.Local.AttributeArticleImage AttributeArticleImage in ListAttributeArticleImage)
                    {
                        if (AttributeArticleImage.AttributeArticle.Pre_Id != null &&
                            AttributeArticleImage.AttributeArticle.Pre_Id != 0)
                        {
                            if (PsProductAttributeImageRepository.ExistProductAttributeImage((UInt32)AttributeArticleImage.AttributeArticle.Pre_Id, (UInt32)AttributeArticleImage.ArticleImage.Pre_Id) == false)
                            {
                                PsProductAttributeImageRepository.Add(new Model.Prestashop.PsProductAttributeImage()
                                {
                                    IDImage            = (UInt32)AttributeArticleImage.ArticleImage.Pre_Id,
                                    IDProductAttribute = (UInt32)AttributeArticleImage.AttributeArticle.Pre_Id,
                                });
                            }
                        }
                    }
                    foreach (Model.Local.CompositionArticleImage CompositionArticleImage in ListCompositionArticleImage)
                    {
                        if (CompositionArticleImage.CompositionArticle.Pre_Id != null &&
                            CompositionArticleImage.CompositionArticle.Pre_Id != 0)
                        {
                            if (PsProductAttributeImageRepository.ExistProductAttributeImage((UInt32)CompositionArticleImage.CompositionArticle.Pre_Id, (UInt32)CompositionArticleImage.ArticleImage.Pre_Id) == false)
                            {
                                PsProductAttributeImageRepository.Add(new Model.Prestashop.PsProductAttributeImage()
                                {
                                    IDImage            = (UInt32)CompositionArticleImage.ArticleImage.Pre_Id,
                                    IDProductAttribute = (UInt32)CompositionArticleImage.CompositionArticle.Pre_Id,
                                });
                            }
                        }
                    }
                }
            }
        }
示例#3
0
        public void Exec(Model.Local.ArticleImage ArticleImage, Model.Local.Article Article, out List <string> log_out)
        {
            log_out = new List <string>();
            try
            {
                // Suppression de l'affectation de l'image à la gamme en local
                Model.Local.AttributeArticleImageRepository AttributeArticleImageRepository = new Model.Local.AttributeArticleImageRepository();
                AttributeArticleImageRepository.DeleteAll(AttributeArticleImageRepository.ListImageArticle(ArticleImage.ImaArt_Id));

                // 07/04/2016 ajout suppression liens compositions
                Model.Local.CompositionArticleImageRepository CompositionArticleImageRepository = new Model.Local.CompositionArticleImageRepository();
                CompositionArticleImageRepository.DeleteAll(CompositionArticleImageRepository.ListImageArticle(ArticleImage.ImaArt_Id));

                // Suppression des fichiers images en local
                if (File.Exists(ArticleImage.SmallFileName))
                {
                    try { File.Delete(ArticleImage.SmallFileName); }
                    catch (Exception ex) { Core.Error.SendMailError(ex.ToString()); }
                }
                if (File.Exists(ArticleImage.TempFileName))
                {
                    try { File.Delete(ArticleImage.TempFileName); }
                    catch (Exception ex) { Core.Error.SendMailError(ex.ToString()); }
                }

                string folder = (Core.Global.GetConfig().ConfigLocalStorageMode == Core.Parametres.LocalStorageMode.advanced_system)
                    ? ArticleImage.advanced_folder
                    : Core.Global.GetConfig().Folders.RootArticle;

                foreach (var fileName in Directory.GetFiles(folder, String.Format("{0}-*" + ArticleImage.GetExtension, ArticleImage.ImaArt_Id)))
                {
                    try { File.Delete(fileName); }
                    catch (Exception ex) { Core.Error.SendMailError(ex.ToString()); }
                }

                if (ArticleImage.Pre_Id != null && ArticleImage.Pre_Id > 0)
                {
                    Model.Prestashop.PsProductAttributeImageRepository PsProductAttributeImageRepository = new Model.Prestashop.PsProductAttributeImageRepository();
                    PsProductAttributeImageRepository.DeleteAll(PsProductAttributeImageRepository.ListImage((uint)ArticleImage.Pre_Id));

                    Model.Prestashop.PsImageLangRepository PsImageLangRepository = new Model.Prestashop.PsImageLangRepository();
                    PsImageLangRepository.DeleteAll(PsImageLangRepository.ListImage((uint)ArticleImage.Pre_Id));

                    // Suppression de l'occurence de l'image sur prestashop
                    Model.Prestashop.PsImageRepository PsImageRepository = new Model.Prestashop.PsImageRepository();
                    Model.Prestashop.PsImage           PsImage           = PsImageRepository.ReadImage((uint)ArticleImage.Pre_Id);

                    if (PsImage != null)
                    {
                        PsImageRepository.Delete(PsImage);

                        try
                        {
                            if (PsImage.Cover == 1 &&
                                !PsImageRepository.ExistProductCover(PsImage.IDProduct, 1) &&
                                PsImageRepository.ExistProduct(PsImage.IDProduct))
                            {
                                List <Model.Prestashop.PsImage> Others   = PsImageRepository.ListProduct(PsImage.IDProduct);
                                Model.Prestashop.PsImage        NewCover = Others.OrderBy(i => i.Position).FirstOrDefault();
                                if (NewCover != null)
                                {
                                    NewCover.Cover = 1;
                                    PsImageRepository.Save();

                                    Core.Transfert.TransfertArticleImage syncimage = new Core.Transfert.TransfertArticleImage();
                                    syncimage.ExecCover(PsImage.IDProduct, true, PsImageRepository, NewCover);

                                    Model.Prestashop.PsImageShopRepository PsImageShopRepository = new Model.Prestashop.PsImageShopRepository();
                                    foreach (Model.Prestashop.PsImageShop PsImageShop in PsImageShopRepository.List(NewCover.IDImage))
                                    {
                                        PsImageShop.Cover = 1;
                                    }
                                    PsImageShopRepository.Save();
                                }
                            }
                        }
                        catch
                        {
                            log_out.Add("II47- Erreur durant la réaffectation de l'image de couverture dans PrestaShop pour l'article " + Article.Art_Ref);
                        }
                        try
                        {
                            foreach (Model.Prestashop.PsImage Image in PsImageRepository.ListProduct(PsImage.IDProduct).Where(i => i.Position > PsImage.Position))
                            {
                                Image.Position--;
                            }
                            PsImageRepository.Save();
                        }
                        catch
                        {
                            log_out.Add("II48- Erreur durant le recalcul des positions dans PrestaShop pour les images de l'article " + Article.Art_Ref);
                        }

                        // Suppression des fichiers images sur prestashop
                        if (Core.Global.GetConfig().ConfigFTPActive)
                        {
                            String FTP      = Core.Global.GetConfig().ConfigFTPIP;
                            String User     = Core.Global.GetConfig().ConfigFTPUser;
                            String Password = Core.Global.GetConfig().ConfigFTPPassword;

                            // <JG> 10/04/2013 gestion système d'images
                            string ftpPath = "/img/p/";
                            switch (Core.Global.GetConfig().ConfigImageStorageMode)
                            {
                            case Core.Parametres.ImageStorageMode.old_system:
                                #region old_system
                                // no action on path
                                break;
                                #endregion

                            case Core.Parametres.ImageStorageMode.new_system:
                            default:
                                #region new_system

                                foreach (char directory in ArticleImage.Pre_Id.ToString())
                                {
                                    ftpPath += directory + "/";
                                }
                                break;
                                #endregion
                            }

                            // <JG> 21/05/2013 correct for 1.5 storage mode
                            string ftpfullpath = (Core.Global.GetConfig().ConfigImageStorageMode == Core.Parametres.ImageStorageMode.old_system)
                                ? FTP + ftpPath + Article.Pre_Id + "-" + ArticleImage.Pre_Id + ".jpg"
                                : FTP + ftpPath + ArticleImage.Pre_Id + ".jpg";

                            FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(ftpfullpath);
                            request.Credentials = new System.Net.NetworkCredential(User, Password);
                            request.Method      = WebRequestMethods.Ftp.DeleteFile;
                            request.UseBinary   = true;
                            request.UsePassive  = true;
                            request.KeepAlive   = false;

                            FtpWebResponse response = (FtpWebResponse)request.GetResponse();
                            response.Close();

                            Model.Prestashop.PsImageTypeRepository PsImageTypeRepository = new Model.Prestashop.PsImageTypeRepository();
                            List <Model.Prestashop.PsImageType>    ListPsImageType       = PsImageTypeRepository.ListProduct(1);

                            foreach (Model.Prestashop.PsImageType PsImageType in ListPsImageType)
                            {
                                try
                                {
                                    // <JG> 21/05/2013 correct for 1.5 storage mode
                                    ftpfullpath = (Core.Global.GetConfig().ConfigImageStorageMode == Core.Parametres.ImageStorageMode.old_system)
                                        ? FTP + ftpPath + Article.Pre_Id + "-" + ArticleImage.Pre_Id + "-" + PsImageType.Name + ".jpg"
                                        : FTP + ftpPath + ArticleImage.Pre_Id + "-" + PsImageType.Name + ".jpg";

                                    request             = (System.Net.FtpWebRequest)System.Net.FtpWebRequest.Create(ftpfullpath);
                                    request.Credentials = new System.Net.NetworkCredential(User, Password);
                                    request.Method      = WebRequestMethods.Ftp.DeleteFile;
                                    request.UseBinary   = true;
                                    request.UsePassive  = true;
                                    request.KeepAlive   = false;

                                    response = (FtpWebResponse)request.GetResponse();
                                    response.Close();
                                }
                                catch {}
                            }
                        }
                    }
                }

                // Suppression de l'occurence de l'image en local
                Model.Local.ArticleImageRepository ArticleImageRepository = new Model.Local.ArticleImageRepository();
                Model.Local.ArticleImage           articleImage           = ArticleImageRepository.ReadArticleImage(ArticleImage.ImaArt_Id);

                if (articleImage != null)
                {
                    ArticleImageRepository.Delete(articleImage);

                    try
                    {
                        if (articleImage.ImaArt_Default &&
                            !ArticleImageRepository.ExistArticleDefault(Article.Art_Id, true) &&
                            ArticleImageRepository.ExistArticle(Article.Art_Id))
                        {
                            Model.Local.ArticleImage NewCover = ArticleImageRepository.ListArticle(Article.Art_Id).OrderBy(i => i.ImaArt_Position).FirstOrDefault();
                            if (NewCover != null)
                            {
                                NewCover.ImaArt_Default = true;
                                ArticleImageRepository.Save();
                            }
                        }
                    }
                    catch
                    {
                        log_out.Add("II43- Erreur durant la réaffectation de l'image de couverture dans PrestaConnect pour l'article " + Article.Art_Ref);
                    }
                    try
                    {
                        foreach (Model.Local.ArticleImage Image in ArticleImageRepository.ListArticle(Article.Art_Id).Where(i => i.ImaArt_Position > articleImage.ImaArt_Position))
                        {
                            Image.ImaArt_Position--;
                        }
                        ArticleImageRepository.Save();
                    }
                    catch
                    {
                        log_out.Add("II44- Erreur durant le recalcul des positions dans PrestaConnect pour les images de l'article " + Article.Art_Ref);
                    }
                }

                log_out.Add("II40- Suppression de l'image " + ArticleImage.ImaArt_SourceFile + " en position " + ArticleImage.ImaArt_Position + " pour l'article " + Article.Art_Ref);
            }
            catch (Exception ex)
            {
                Core.Error.SendMailError(ex.ToString());
            }
        }