private void ExecLocalToDistant(Model.Local.Article Article, Model.Prestashop.PsProduct Product, Model.Local.ArticleRepository ArticleRepository, Model.Prestashop.PsProductRepository ProductRepository, Boolean isProduct)
{
try
{
if (isProduct)
{
Model.Local.CatalogRepository CatalogRepository = new Model.Local.CatalogRepository();
Model.Local.Catalog Catalog = CatalogRepository.ReadId(Article.Cat_Id);
if (Catalog.Pre_Id != null && new Model.Prestashop.PsCategoryRepository().ExistId((int)Catalog.Pre_Id))
{
Product.IDCategoryDefault = Convert.ToUInt32(Catalog.Pre_Id);
ProductRepository.Save();
this.AssignCatalogProduct(Article, Product, ArticleRepository);
// <JG> 17/12/2012
this.ExecShopProduct(Product);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void Exec(Int32 ArticleSend)
{
try
{
Model.Local.ArticleRepository ArticleRepository = new Model.Local.ArticleRepository();
Model.Local.Article Article = ArticleRepository.ReadArticle(ArticleSend);
Model.Prestashop.PsProductRepository ProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct Product = new Model.Prestashop.PsProduct();
// If the Article have a connection with Prestashop
if (Article.Pre_Id != null)
{
//Article.Art_Date = Article.Art_Date.AddMilliseconds(-Article.Art_Date.Millisecond);
if (ProductRepository.ExistId(Convert.ToUInt32(Article.Pre_Id.Value)))
{
Product = ProductRepository.ReadId(Convert.ToUInt32(Article.Pre_Id.Value));
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
SynchronisationArticle.ExecFeature(Article);
}
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void Exec(Int32 ArticleSend)
{
try
{
Model.Local.ArticleRepository ArticleRepository = new Model.Local.ArticleRepository();
Model.Local.Article Article = ArticleRepository.ReadArticle(ArticleSend);
// If the catalog is sync with Prestashop
//if (Article.Catalog.Pre_Id != null || Article.Catalog.Pre_Id != 0)
{
Model.Prestashop.PsProductRepository ProductRepository = new Model.Prestashop.PsProductRepository();
Boolean isProduct = false;
// If the Article have a connection with Prestashop
if (Article.Pre_Id != null &&
ProductRepository.ExistId(Convert.ToUInt32(Article.Pre_Id.Value)))
{
Model.Prestashop.PsProduct Product = ProductRepository.ReadId(Convert.ToUInt32(Article.Pre_Id.Value));
isProduct = true;
if (Product.DateUpd.Ticks > Article.Art_Date.Ticks)
{
this.ExecDistantToLocal(Product, Article, ArticleRepository);
}
else if (Product.DateUpd.Ticks < Article.Art_Date.Ticks)
{
this.ExecLocalToDistant(Article, Product, ArticleRepository, ProductRepository, isProduct);
}
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void Exec(Int32 ArticleSend)
{
try
{
Model.Local.ArticleRepository ArticleRepository = new Model.Local.ArticleRepository();
Model.Local.Article Article = ArticleRepository.ReadArticle(ArticleSend);
// If the catalog is sync with Prestashop
if (Article.Catalog.Pre_Id != null || Article.Catalog.Pre_Id != 0)
{
Model.Prestashop.PsProductRepository ProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct Product = new Model.Prestashop.PsProduct();
// If the Article have a connection with Prestashop
if (Article.Pre_Id != null)
{
if (ProductRepository.ExistId(Convert.ToUInt32(Article.Pre_Id.Value)))
{
this.ExecLocalToDistant(Article);
}
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void RecoveryChildData(Model.Local.Article Article, Model.Prestashop.PsProduct PsProduct, Model.Local.ArticleRepository ArticleRepository, Boolean ExistLocal)
{
ReadRedirection(Article);
AssociateCatalogue(PsProduct, Article, ArticleRepository);
RecoveryDataProductAttribute(PsProduct);
ImportCharacteristic(PsProduct, Article, true);
}
private void AssignCatalogProduct(Model.Local.Article Article, Model.Prestashop.PsProduct Product, Model.Local.ArticleRepository ArticleRepository)
{
try
{
Model.Local.ArticleCatalogRepository ArticleCatalogRepository = new Model.Local.ArticleCatalogRepository();
Model.Local.CatalogRepository CatalogRepository = new Model.Local.CatalogRepository();
Model.Prestashop.PsCategoryProductRepository PsCategoryProductRepository = new Model.Prestashop.PsCategoryProductRepository();
Model.Prestashop.PsCategoryRepository PsCategoryRepository = new Model.Prestashop.PsCategoryRepository();
// filtrage des catalogues existants dans PC et PS
List <Model.Local.CatalogLight> ListLocalCatalog = CatalogRepository.ListLight();
List <uint> ListPrestashopCategory = PsCategoryRepository.ListIdOrderByLevelDepth(Core.Global.CurrentShop.IDShop, PsCategoryRepository.ReadId(Core.Global.CurrentShop.IDCategory).LevelDepth);
ListLocalCatalog = ListLocalCatalog.Where(lc => ListPrestashopCategory.Count(pc => pc == (uint)lc.Pre_Id) > 0).ToList();
// filtrage des associations PS par rapport aux catégories PS existantes en tant que catalogue PC
List <Model.Prestashop.PsCategoryProduct> ListPsCategoryProduct = PsCategoryProductRepository.ListProduct(Product.IDProduct);
ListPsCategoryProduct = ListPsCategoryProduct.Where(cp => ListLocalCatalog.Count(lc => lc.Pre_Id == cp.IDCategory) > 0).ToList();
// filtrage des associations PC par rapport aux catégories ayant un ID PS
List <Model.Local.ArticleCatalog> ListLocal = ArticleCatalogRepository.ListArticle(Article.Art_Id);
ListLocal = ListLocal.Where(ac => ac.Catalog.Pre_Id != null).ToList();
if (Core.Global.GetConfig().DeleteCatalogProductAssociation)
{
// suppressions des associations inexistantes dans PC
while (ListPsCategoryProduct.Count(cp => ListLocal.Count(ac => ac.Catalog.Pre_Id == cp.IDCategory) == 0) > 0)
{
Model.Prestashop.PsCategoryProduct target = ListPsCategoryProduct.FirstOrDefault(cp => ListLocal.Count(ac => ac.Catalog.Pre_Id == cp.IDCategory) == 0);
PsCategoryProductRepository.Delete(target);
ListPsCategoryProduct.Remove(target);
}
;
}
ListLocal = ListLocal.Where(ac => ListPsCategoryProduct.Count(cp => cp.IDCategory == ac.Catalog.Pre_Id) == 0).ToList();
foreach (Model.Local.ArticleCatalog ArticleCatalog in ListLocal)
{
uint IDCategory = (UInt32)ArticleCatalog.Catalog.Pre_Id;
PsCategoryProductRepository.Add(new Model.Prestashop.PsCategoryProduct()
{
IDProduct = Product.IDProduct,
IDCategory = IDCategory,
Position = Model.Prestashop.PsCategoryProductRepository.NextPositionProductCatalog(IDCategory),
});
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void ImportCharacteristic(Model.Prestashop.PsProduct PsProduct, Model.Local.Article Article, bool ArticleExists)
{
Model.Local.ConfigRepository ConfigRepository = new Model.Local.ConfigRepository();
Model.Local.Config Config = ConfigRepository.ReadName(Global.ConfigLang);
if (Config != null && Global.IsNumeric(Config.Con_Value))
{
Model.Prestashop.PsFeatureProductRepository PsFeatureProductRepository = new Model.Prestashop.PsFeatureProductRepository();
Model.Prestashop.PsFeatureValueRepository PsFeatureValueRepository = new Model.Prestashop.PsFeatureValueRepository();
Model.Prestashop.PsFeatureValueLangRepository PsFeatureValueLangRepository = new Model.Prestashop.PsFeatureValueLangRepository();
Model.Local.CharacteristicRepository CharacteristicRepository = new Model.Local.CharacteristicRepository();
foreach (Model.Prestashop.PsFeatureProduct FeatureProduct in PsFeatureProductRepository.List(PsProduct.IDProduct))
{
Model.Prestashop.PsFeatureValue PsFeatureValue = PsFeatureValueRepository.ReadFeatureValue(FeatureProduct.IDFeatureValue);
Model.Prestashop.PsFeatureValueLang PsFeatureValueLang = PsFeatureValueLangRepository.ReadFeatureValueLang(FeatureProduct.IDFeatureValue, Convert.ToUInt32(Config.Con_Value));
Model.Local.Characteristic Characteristic = null;
if (ArticleExists)
{
Characteristic = CharacteristicRepository.ReadFeatureArticle((int)FeatureProduct.IDFeature, Article.Art_Id);
}
if (!ArticleExists || Characteristic == null)
{
Characteristic = new Model.Local.Characteristic()
{
Art_Id = Article.Art_Id,
Cha_Custom = Convert.ToBoolean(PsFeatureValue.Custom),
Cha_IdFeature = (int)FeatureProduct.IDFeature,
Cha_Value = PsFeatureValueLang.Value,
Pre_Id = (int)FeatureProduct.IDFeatureValue,
};
CharacteristicRepository.Add(Characteristic);
}
else
{
Characteristic.Cha_Custom = Convert.ToBoolean(PsFeatureValue.Custom);
Characteristic.Cha_Value = PsFeatureValueLang.Value;
Characteristic.Pre_Id = (int)FeatureProduct.IDFeatureValue;
CharacteristicRepository.Save();
}
}
}
}
private void ExecLocalToDistant(Model.Local.Article Article, Model.Prestashop.PsProduct Product, Model.Prestashop.PsProductRepository ProductRepository)
{
try
{
if (Article.TypeArticle == Model.Local.Article.enum_TypeArticle.ArticleComposition)
{
if (Core.UpdateVersion.License.Option2)
{
Product.Quantity = 0;
Product.Price = 0;
SynchronisationArticle.WriteStockAvailableProduct(Product);
SynchronisationArticle.ExecCompositionArticle(Article, Product, ProductRepository);
}
}
else
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(Article.Sag_Id);
if ((F_ARTICLE.AR_Gamme1 != null && F_ARTICLE.AR_Gamme1 != 0) || (F_ARTICLE.AR_Condition != null && F_ARTICLE.AR_Condition != 0))
{
int CatComptaArticle = Core.Global.GetConfig().ConfigArticleCatComptable;
Model.Sage.F_TAXE TaxeTVA = SynchronisationArticle.ReadTaxe(F_ARTICLE, Product, CatComptaArticle);
Model.Sage.F_TAXE TaxeEco = SynchronisationArticle.ReadEcoTaxe(F_ARTICLE, Product, TaxeTVA, CatComptaArticle);
SynchronisationArticle.ReadPrice(F_ARTICLE, Product, TaxeTVA);
// <JG> 19/02/2013 déplacement pour correction problème prix spécifiques lors de la création de l'article
SynchronisationArticle.ExecAttribute(Article, Product, ProductRepository, TaxeTVA);
SynchronisationArticle.ExecConditioning(Article, Product, ProductRepository, TaxeTVA);
//List<string> log;
//SynchronisationArticle.ExecSpecificPrice(F_ARTICLE, Product, Article.Art_Id, TaxeTVA, TaxeEco, out log);
}
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void Exec(Int32 ArticleSend, out List <string> log_chrono, out uint pre_id)
{
log_chrono = new List <string>();
pre_id = 0;
try
{
Model.Local.ArticleRepository ArticleRepository = new Model.Local.ArticleRepository();
Model.Local.Article Article = ArticleRepository.ReadArticle(ArticleSend);
DateTime start = DateTime.UtcNow;
if (Core.Global.GetConfig().ChronoSynchroStockPriceActif)
{
log_chrono.Add("----" + Article.Art_Ref + "----" + start.ToString("HH:mm:ss.fff", System.Globalization.CultureInfo.InvariantCulture));
}
Model.Prestashop.PsProductRepository ProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct Product = new Model.Prestashop.PsProduct();
// If the Article have a connection with Prestashop
if (Article.Pre_Id != null)
{
//Article.Art_Date = Article.Art_Date.AddMilliseconds(-Article.Art_Date.Millisecond);
if (ProductRepository.ExistId(Convert.ToUInt32(Article.Pre_Id.Value)))
{
Product = ProductRepository.ReadId(Convert.ToUInt32(Article.Pre_Id.Value));
List <string> log;
this.ExecLocalToDistant(Article, Product, ProductRepository, out log);
if (log != null && log.Count > 0)
{
log_chrono.AddRange(log);
}
pre_id = Product.IDProduct;
}
}
if (Core.Global.GetConfig().ChronoSynchroStockPriceActif)
{
log_chrono.Add("----" + Article.Art_Ref + "----" + (DateTime.UtcNow - start).ToString());
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void Exec(Int32 ArticleSend)
{
try
{
Model.Local.ArticleRepository ArticleRepository = new Model.Local.ArticleRepository();
Model.Local.Article Article = ArticleRepository.ReadArticle(ArticleSend);
Model.Prestashop.PsProductRepository ProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct Product = new Model.Prestashop.PsProduct();
// If the Article have a connection with Prestashop
if (Article.Pre_Id != null)
{
//Article.Art_Date = Article.Art_Date.AddMilliseconds(-Article.Art_Date.Millisecond);
if (ProductRepository.ExistId(Convert.ToUInt32(Article.Pre_Id.Value)))
{
Product = ProductRepository.ReadId(Convert.ToUInt32(Article.Pre_Id.Value));
this.ExecLocalToDistant(Article, ArticleRepository, Product, ProductRepository);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
private void RecoveryDataProductAttribute(Model.Prestashop.PsProduct Product)
{
Model.Prestashop.PsProductAttributeRepository PsProductAttributeRepository = new Model.Prestashop.PsProductAttributeRepository();
Model.Prestashop.PsProductAttributeShopRepository PsProductAttributeShopRepository = new Model.Prestashop.PsProductAttributeShopRepository();
Model.Prestashop.PsProductAttributeImageRepository PsProductAttributeImageRepository = new Model.Prestashop.PsProductAttributeImageRepository();
Model.Local.AttributeArticleRepository AttributeArticleRepository = new Model.Local.AttributeArticleRepository();
Model.Local.ConditioningArticleRepository ConditioningArticleRepository = new Model.Local.ConditioningArticleRepository();
Model.Local.CompositionArticleRepository CompositionArticleRepository = new Model.Local.CompositionArticleRepository();
Model.Local.AttributeArticleImageRepository AttributeArticleImageRepository = new Model.Local.AttributeArticleImageRepository();
Model.Local.CompositionArticleImageRepository CompositionArticleImageRepository = new Model.Local.CompositionArticleImageRepository();
Model.Local.ArticleImageRepository ArticleImageRepository = new Model.Local.ArticleImageRepository();
Model.Local.AttributeArticle AttributeArticle;
Model.Local.ConditioningArticle ConditioningArticle;
Model.Local.CompositionArticle CompositionArticle;
Model.Local.ArticleImage ArticleImage;
List <Model.Prestashop.PsProductAttribute> ListPsProductAttribute = PsProductAttributeRepository.List(Product.IDProduct);
//parcours déclinaisons PrestaShop
foreach (Model.Prestashop.PsProductAttribute PsProductAttribute in ListPsProductAttribute)
{
// test si déclinaison en gamme dans PrestaConnect
if (AttributeArticleRepository.ExistPrestashop((int)PsProductAttribute.IDProductAttribute))
{
AttributeArticle = AttributeArticleRepository.ReadPrestashop((int)PsProductAttribute.IDProductAttribute);
Model.Prestashop.PsProductAttributeShop PsProductAttributeShop = (PsProductAttributeShopRepository.ExistPsProductAttributeShop(PsProductAttribute.IDProductAttribute, Core.Global.CurrentShop.IDShop))
? PsProductAttributeShopRepository.ReadPsProductAttributeShop(PsProductAttribute.IDProductAttribute, Core.Global.CurrentShop.IDShop)
: null;
bool defaut = (PsProductAttributeShop != null) ? PsProductAttributeShop.DefaultOn == 1 : PsProductAttribute.DefaultOn == 1;
if (AttributeArticle.AttArt_Default != defaut)
{
AttributeArticle.AttArt_Default = defaut;
AttributeArticleRepository.Save();
if (defaut)
{
List <Model.Local.AttributeArticle> ListAttributeArticle = AttributeArticleRepository.ListArticle(AttributeArticle.Art_Id);
if (ListAttributeArticle.Count(i => i.AttArt_Default == true && i.AttArt_Id != AttributeArticle.AttArt_Id) > 0)
{
foreach (Model.Local.AttributeArticle AttributeArticleDefault in ListAttributeArticle.Where(i => i.AttArt_Default == true && i.AttArt_Id != AttributeArticle.Art_Id))
{
AttributeArticleDefault.AttArt_Default = false;
AttributeArticleRepository.Save();
}
}
}
}
// attribution images gammes
if (PsProductAttributeImageRepository.ExistProductAttribute(PsProductAttribute.IDProductAttribute))
{
List <Model.Prestashop.PsProductAttributeImage> ListPsProductAttributeImage = PsProductAttributeImageRepository.ListProductAttribute(PsProductAttribute.IDProductAttribute);
// étape 1 attachement dans PrestaConnect des images affectées a la déclinaison PrestaShop
foreach (Model.Prestashop.PsProductAttributeImage PsProductAttributeImage in ListPsProductAttributeImage)
{
// si l'image existe dans PrestaConnect
if (ArticleImageRepository.ExistPre_Id((int)PsProductAttributeImage.IDImage))
{
ArticleImage = ArticleImageRepository.ReadPrestaShop((int)PsProductAttributeImage.IDImage);
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,
});
}
}
}
// étape 2 détachement
List <uint> list_prestashop = ListPsProductAttributeImage.Select(pai => pai.IDImage).ToList();
foreach (Model.Local.AttributeArticleImage AttributeArticleImage in AttributeArticleImageRepository.ListAttributeArticle(AttributeArticle.AttArt_Id))
{
if (AttributeArticleImage.ArticleImage.Pre_Id != null &&
!list_prestashop.Contains((uint)AttributeArticleImage.ArticleImage.Pre_Id.Value))
{
AttributeArticleImageRepository.Delete(AttributeArticleImage);
}
}
}
else if (AttributeArticleImageRepository.ExistAttributeArticle(AttributeArticle.AttArt_Id))
{
// absence de lien gamme déclinaison dans Prestashop donc suppression des liens dans PrestaConnect
AttributeArticleImageRepository.DeleteAll(AttributeArticleImageRepository.ListAttributeArticle(AttributeArticle.AttArt_Id));
}
}
// test si déclinaison en conditionnement dans PrestaConnect
else if (ConditioningArticleRepository.ExistPrestashop((int)PsProductAttribute.IDProductAttribute))
{
ConditioningArticle = ConditioningArticleRepository.ReadPrestashop((int)PsProductAttribute.IDProductAttribute);
Model.Prestashop.PsProductAttributeShop PsProductAttributeShop = (PsProductAttributeShopRepository.ExistPsProductAttributeShop(PsProductAttribute.IDProductAttribute, Core.Global.CurrentShop.IDShop))
? PsProductAttributeShopRepository.ReadPsProductAttributeShop(PsProductAttribute.IDProductAttribute, Core.Global.CurrentShop.IDShop)
: null;
bool defaut = (PsProductAttributeShop != null) ? PsProductAttributeShop.DefaultOn == 1 : PsProductAttribute.DefaultOn == 1;
if (ConditioningArticle.ConArt_Default != defaut)
{
ConditioningArticle.ConArt_Default = defaut;
ConditioningArticleRepository.Save();
if (defaut)
{
List <Model.Local.ConditioningArticle> ListConditioningArticle = ConditioningArticleRepository.ListArticle(ConditioningArticle.Art_Id);
if (ListConditioningArticle.Count(i => i.ConArt_Default == true && i.ConArt_Id != ConditioningArticle.ConArt_Id) > 0)
{
foreach (Model.Local.ConditioningArticle ConditioningArticleDefault in ListConditioningArticle.Where(i => i.ConArt_Default == true && i.ConArt_Id != ConditioningArticle.Art_Id))
{
ConditioningArticleDefault.ConArt_Default = false;
ConditioningArticleRepository.Save();
}
}
}
}
}
// test si déclinaison composition dans PrestaConnect
else if (CompositionArticleRepository.ExistPrestaShop((int)PsProductAttribute.IDProductAttribute))
{
CompositionArticle = CompositionArticleRepository.ReadPrestaShop((int)PsProductAttribute.IDProductAttribute);
Model.Prestashop.PsProductAttributeShop PsProductAttributeShop = (PsProductAttributeShopRepository.ExistPsProductAttributeShop(PsProductAttribute.IDProductAttribute, Core.Global.CurrentShop.IDShop))
? PsProductAttributeShopRepository.ReadPsProductAttributeShop(PsProductAttribute.IDProductAttribute, Core.Global.CurrentShop.IDShop)
: null;
bool defaut = (PsProductAttributeShop != null) ? PsProductAttributeShop.DefaultOn == 1 : PsProductAttribute.DefaultOn == 1;
if (CompositionArticle.ComArt_Default != defaut)
{
CompositionArticle.ComArt_Default = defaut;
CompositionArticleRepository.Save();
if (defaut)
{
List <Model.Local.CompositionArticle> ListCompositionArticle = CompositionArticleRepository.ListArticle(CompositionArticle.ComArt_ArtId);
if (ListCompositionArticle.Count(i => i.ComArt_Default == true && i.ComArt_Id != CompositionArticle.ComArt_Id) > 0)
{
foreach (Model.Local.CompositionArticle CompositionArticleDefault in ListCompositionArticle.Where(i => i.ComArt_Default == true && i.ComArt_Id != CompositionArticle.ComArt_ArtId))
{
CompositionArticleDefault.ComArt_Default = false;
ConditioningArticleRepository.Save();
}
}
}
}
// attribution images gammes
if (PsProductAttributeImageRepository.ExistProductAttribute(PsProductAttribute.IDProductAttribute))
{
List <Model.Prestashop.PsProductAttributeImage> ListPsProductAttributeImage = PsProductAttributeImageRepository.ListProductAttribute(PsProductAttribute.IDProductAttribute);
// étape 1 attachement dans PrestaConnect des images affectées a la déclinaison PrestaShop
foreach (Model.Prestashop.PsProductAttributeImage PsProductAttributeImage in ListPsProductAttributeImage)
{
// si l'image existe dans PrestaConnect
if (ArticleImageRepository.ExistPre_Id((int)PsProductAttributeImage.IDImage))
{
ArticleImage = ArticleImageRepository.ReadPrestaShop((int)PsProductAttributeImage.IDImage);
if (!CompositionArticleImageRepository.ExistCompositionArticleImage(CompositionArticle.ComArt_Id, ArticleImage.ImaArt_Id))
{
CompositionArticleImageRepository.Add(new Model.Local.CompositionArticleImage()
{
ComArt_Id = CompositionArticle.ComArt_Id,
ImaArt_Id = ArticleImage.ImaArt_Id,
});
}
}
}
// étape 2 détachement
List <uint> list_prestashop = ListPsProductAttributeImage.Select(pai => pai.IDImage).ToList();
foreach (Model.Local.CompositionArticleImage CompositionArticleImage in CompositionArticleImageRepository.ListCompositionArticle(CompositionArticle.ComArt_Id))
{
if (CompositionArticleImage.ArticleImage.Pre_Id != null &&
!list_prestashop.Contains((uint)CompositionArticleImage.ArticleImage.Pre_Id.Value))
{
CompositionArticleImageRepository.Delete(CompositionArticleImage);
}
}
}
else if (CompositionArticleImageRepository.ExistCompositionArticle(CompositionArticle.ComArt_Id))
{
// absence de lien gamme déclinaison dans Prestashop donc suppression des liens dans PrestaConnect
CompositionArticleImageRepository.DeleteAll(CompositionArticleImageRepository.ListCompositionArticle(CompositionArticle.ComArt_Id));
}
}
}
}
//<YH> 23/08/2012
private void ExecLocalToDistant(Model.Local.Article Article)
{
try
{
Model.Prestashop.PsAttachmentRepository PsAttachmentRepository = new Model.Prestashop.PsAttachmentRepository();
Model.Prestashop.PsAttachment PsAttachment;
Model.Prestashop.PsAttachmentLangRepository PsAttachmentLangRepository = new Model.Prestashop.PsAttachmentLangRepository();
Model.Prestashop.PsAttachmentLang PsAttachmentLang;
Model.Prestashop.PsProductAttachmentRepository PsProductAttachmentRepository = new Model.Prestashop.PsProductAttachmentRepository();
Model.Prestashop.PsProductAttachment PsProductAttachment;
Boolean isAttachmentLang = false;
String FTP = Core.Global.GetConfig().ConfigFTPIP;
String User = Core.Global.GetConfig().ConfigFTPUser;
String Password = Core.Global.GetConfig().ConfigFTPPassword;
Model.Local.AttachmentRepository AttachmentRepository = new Model.Local.AttachmentRepository();
List <Model.Local.Attachment> ListAttachment = AttachmentRepository.ListArticle(Article.Art_Id);
foreach (Model.Local.Attachment Attachment in ListAttachment)
{
try
{
if (Attachment.Pre_Id == null)
{
String PathAttachment = Path.Combine(Global.GetConfig().Folders.RootAttachment, Attachment.Att_File);
if (System.IO.File.Exists(PathAttachment))
{
#region infos document joint
PsAttachment = new Model.Prestashop.PsAttachment();
PsAttachment.File = Attachment.Att_File;
PsAttachment.FileName = Attachment.Att_FileName;
PsAttachment.Mime = Attachment.Att_Mime;
PsAttachmentRepository.Add(PsAttachment);
isAttachmentLang = false;
PsAttachmentLang = new Model.Prestashop.PsAttachmentLang();
if (PsAttachmentLangRepository.ExistAttachmentLang(PsAttachment.IDAttachment, Core.Global.Lang))
{
PsAttachmentLang = PsAttachmentLangRepository.ReadAttachmentLang(PsAttachment.IDAttachment, Core.Global.Lang);
isAttachmentLang = true;
}
PsAttachmentLang.Name = Attachment.Att_Name;
PsAttachmentLang.Description = Attachment.Att_Description;
if (isAttachmentLang == true)
{
PsAttachmentLangRepository.Save();
}
else
{
PsAttachmentLang.IDAttachment = PsAttachment.IDAttachment;
PsAttachmentLang.IDLang = Core.Global.Lang;
PsAttachmentLangRepository.Add(PsAttachmentLang);
}
#endregion
// <JG> 24/05/2013 ajout insertion autres langues actives si non renseignées
#region Multi-langues
try
{
Model.Prestashop.PsLangRepository PsLangRepository = new Model.Prestashop.PsLangRepository();
foreach (Model.Prestashop.PsLang PsLang in PsLangRepository.ListActive(1, Global.CurrentShop.IDShop))
{
if (!PsAttachmentLangRepository.ExistAttachmentLang(PsAttachment.IDAttachment, PsLang.IDLang))
{
PsAttachmentLang = new Model.Prestashop.PsAttachmentLang()
{
IDAttachment = PsAttachment.IDAttachment,
IDLang = PsLang.IDLang,
Name = Attachment.Att_Name,
Description = Attachment.Att_Description
};
PsAttachmentLangRepository.Add(PsAttachmentLang);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
#endregion
// affectation au produit
PsProductAttachment = new Model.Prestashop.PsProductAttachment();
if (PsProductAttachmentRepository.ExistProductAttachment(Convert.ToUInt32(Article.Pre_Id), PsAttachment.IDAttachment) == false)
{
PsProductAttachment.IDProduct = Convert.ToUInt32(Article.Pre_Id);
PsProductAttachment.IDAttachment = PsAttachment.IDAttachment;
PsProductAttachmentRepository.Add(PsProductAttachment);
}
try
{
#region upload
string ftpfullpath = FTP + "/download/" + Attachment.Att_File;
System.Net.FtpWebRequest ftp = (System.Net.FtpWebRequest)System.Net.FtpWebRequest.Create(ftpfullpath);
ftp.Credentials = new System.Net.NetworkCredential(User, Password);
//userid and password for the ftp server to given
ftp.UseBinary = true;
ftp.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
System.IO.FileStream fs = System.IO.File.OpenRead(PathAttachment);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
fs.Close();
System.IO.Stream ftpstream = ftp.GetRequestStream();
ftpstream.Write(buffer, 0, buffer.Length);
ftpstream.Close();
ftp.Abort();
#endregion
#region update Product field cache_as_attachements
Model.Prestashop.PsProductRepository PsProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct PsProduct = PsProductRepository.ReadId(PsProductAttachment.IDProduct);
if (PsProduct.CacheHasAttachments == 0)
{
PsProduct.CacheHasAttachments = (sbyte)1;
PsProductRepository.Save();
}
#endregion
Attachment.Pre_Id = Convert.ToInt32(PsAttachment.IDAttachment);
AttachmentRepository.Save();
}
catch (Exception ex)
{
Core.Error.SendMailError("[UPLOAD FTP DOCUMENT]<br />" + ex.ToString());
PsProductAttachmentRepository.Delete(PsProductAttachmentRepository.ListAttachment(PsAttachment.IDAttachment));
PsAttachmentLangRepository.Delete(PsAttachmentLangRepository.ListAttachment(PsAttachment.IDAttachment));
PsAttachmentRepository.Delete(PsAttachment);
}
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError("[SYNCHRO DOCUMENT ARTICLE]<br />" + ex.ToString());
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
private void ExecLocalToDistant(Model.Local.Article Article, Model.Prestashop.PsProduct Product, Model.Prestashop.PsProductRepository PsProductRepository)
{
try
{
if (Article.TypeArticle == Model.Local.Article.enum_TypeArticle.ArticleComposition)
{
if (Core.UpdateVersion.License.Option2)
{
Product.Quantity = 0;
SynchronisationArticle.WriteStockAvailableProduct(Product);
ExecCompositionArticle(Article, Product);
}
}
else
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(Article.Sag_Id);
SynchronisationArticle.ReadQuantity(F_ARTICLE, Product);
#region Stock pack limité par composés
if (Article.Art_Pack == true || F_ARTICLE.AR_Nomencl == (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_Nomencl.Commerciale_Composant ||
F_ARTICLE.AR_Nomencl == (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_Nomencl.Commerciale_Compose) // pour que les articles en nomenclature soient pris en compte
{
Model.Sage.F_NOMENCLATRepository F_NOMENCLATRepository = new Model.Sage.F_NOMENCLATRepository();
List <Model.Sage.F_NOMENCLAT> ListF_NOMENCLAT = F_NOMENCLATRepository.ListRef(F_ARTICLE.AR_Ref);
Model.Sage.F_ARTICLE F_ARTICLENOMENCLAT;
Int32 QuantityPack = 0;
foreach (Model.Sage.F_NOMENCLAT F_NOMENCLAT in ListF_NOMENCLAT)
{
if (F_ARTICLERepository.ExistReference(F_NOMENCLAT.NO_RefDet))
{
F_ARTICLENOMENCLAT = F_ARTICLERepository.ReadReference(F_NOMENCLAT.NO_RefDet);
if (F_ARTICLENOMENCLAT.AR_SuiviStock != (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_SuiviStock.Aucun) // pour ne pas prendre en compte les articles non suivi en stock
{
Int32 CurrentQuantity = SynchronisationArticle.ReadQuantityPack(F_ARTICLENOMENCLAT, F_NOMENCLAT.NO_Qte.Value);
if (Core.Global.GetConfig().ArticleStockNegatifZero&& CurrentQuantity < 0)
{
CurrentQuantity = 0;
}
if (CurrentQuantity < QuantityPack)
{
QuantityPack = CurrentQuantity;
// <AM> 14/08/2014 Si un des articles composant n'a pas de stock on sort de la fonction pour que l'article parent ai un stock à 0
if (CurrentQuantity == 0)
{
break;
}
}
else if (QuantityPack == 0)
{
QuantityPack = CurrentQuantity;
// <AM> 14/08/2014 Si un des articles composant n'a pas de stock on sort de la fonction pour que l'article parent ai un stock à 0
if (CurrentQuantity == 0)
{
break;
}
}
}
}
}
Product.Quantity = QuantityPack;
}
#endregion
// <JG> 29/10/2012 ajout synchronisation des stocks seule
//SynchronisationArticle.ReadEcoTaxe(F_ARTICLE, Product);
//SynchronisationArticle.ReadPrice(F_ARTICLE, Product);
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeight(F_ARTICLE, Product);
}
if (Core.Global.GetConfig().ArticleDateDispoInfoLibreActif)
{
SynchronisationArticle.ReadDateDispo(Product, F_ARTICLE);
}
PsProductRepository.Save();
PsProductRepository.WriteDate(Product.IDProduct);
this.ExecAttribute(Article, Product, PsProductRepository);
this.ExecConditioning(Article, Product, PsProductRepository);
//SynchronisationArticle.ExecSpecificPrice(F_ARTICLE, Product);
// <JG> 17/12/2012
SynchronisationArticle.ExecShopProduct(Product);
SynchronisationArticle.WriteStockAvailableProduct(Product);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
private void ExecLocalToDistant(Model.Local.Article Article, Model.Prestashop.PsProduct Product, Model.Prestashop.PsProductRepository PsProductRepository,
out List <string> log_chrono)
{
log_chrono = new List <string>();
try
{
if (Article.TypeArticle == Model.Local.Article.enum_TypeArticle.ArticleComposition)
{
if (Core.UpdateVersion.License.Option2)
{
Product.Price = 0;
Product.Quantity = 0;
SynchronisationArticle.WriteStockAvailableProduct(Product);
ExecCompositionArticle(Article, Product);
}
}
else
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(Article.Sag_Id);
SynchronisationArticle.ReadQuantity(F_ARTICLE, Product);
#region Stock pack limité par composés
if (Article.Art_Pack == true || F_ARTICLE.AR_Nomencl == (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_Nomencl.Commerciale_Composant ||
F_ARTICLE.AR_Nomencl == (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_Nomencl.Commerciale_Compose) // pour que les articles en nomenclature soient pris en compte
{
Model.Sage.F_NOMENCLATRepository F_NOMENCLATRepository = new Model.Sage.F_NOMENCLATRepository();
List <Model.Sage.F_NOMENCLAT> ListF_NOMENCLAT = F_NOMENCLATRepository.ListRef(F_ARTICLE.AR_Ref);
Model.Sage.F_ARTICLE F_ARTICLENOMENCLAT;
Int32 QuantityPack = 0;
foreach (Model.Sage.F_NOMENCLAT F_NOMENCLAT in ListF_NOMENCLAT)
{
if (F_ARTICLERepository.ExistReference(F_NOMENCLAT.NO_RefDet))
{
F_ARTICLENOMENCLAT = F_ARTICLERepository.ReadReference(F_NOMENCLAT.NO_RefDet);
if (F_ARTICLENOMENCLAT.AR_SuiviStock != (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_SuiviStock.Aucun) // pour ne pas prendre en compte les articles non suivi en stock
{
Int32 CurrentQuantity = SynchronisationArticle.ReadQuantityPack(F_ARTICLENOMENCLAT, F_NOMENCLAT.NO_Qte.Value);
if (Core.Global.GetConfig().ArticleStockNegatifZero&& CurrentQuantity < 0)
{
CurrentQuantity = 0;
}
if (CurrentQuantity < QuantityPack)
{
QuantityPack = CurrentQuantity;
}
else if (QuantityPack == 0)
{
QuantityPack = CurrentQuantity;
// <AM> 14/08/2014 Si un des articles composant n'a pas de stock on sort de la fonction pour que l'article parent ai un stock à 0
if (CurrentQuantity == 0)
{
break;
}
}
}
}
}
Product.Quantity = QuantityPack;
}
#endregion
int CatComptaArticle = Core.Global.GetConfig().ConfigArticleCatComptable;
Model.Sage.F_TAXE TaxeTVA = SynchronisationArticle.ReadTaxe(F_ARTICLE, Product, CatComptaArticle);
Model.Sage.F_TAXE TaxeEco = SynchronisationArticle.ReadEcoTaxe(F_ARTICLE, Product, TaxeTVA, CatComptaArticle);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPrice(F_ARTICLE, Product, TaxeTVA);
}
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeight(F_ARTICLE, Product);
}
if (Core.Global.GetConfig().ArticleDateDispoInfoLibreActif)
{
SynchronisationArticle.ReadDateDispo(Product, F_ARTICLE);
}
PsProductRepository.Save();
PsProductRepository.WriteDate(Product.IDProduct);
// <JG> 05/11/2013 déplacement pour application taxes et pdt spécifiques sur nouvelles déclinaisons
this.ExecAttribute(Article, Product, TaxeTVA, PsProductRepository);
this.ExecConditioning(Article, Product, TaxeTVA, PsProductRepository);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
List <string> log;
SynchronisationArticle.ExecSpecificPrice(F_ARTICLE, Product, Article, null, TaxeTVA, TaxeEco, out log);
if (log != null && log.Count > 0)
{
log_chrono.AddRange(log);
}
}
// <JG> 17/12/2012
SynchronisationArticle.ExecShopProduct(Product);
SynchronisationArticle.WriteStockAvailableProduct(Product);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
private void ExecCompositionArticle(Model.Local.Article Article, Model.Prestashop.PsProduct Product)
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
Model.Local.CompositionArticleRepository CompositionArticleRepository = new Model.Local.CompositionArticleRepository();
List <Model.Local.CompositionArticle> ListCompositionArticle = CompositionArticleRepository.ListArticle(Article.Art_Id);
foreach (var item in ListCompositionArticle)
{
try
{
Model.Sage.F_ARTICLE_Composition F_ARTICLE_Composition = F_ARTICLERepository.ReadComposition(item.ComArt_F_ARTICLE_SagId, item.ComArt_F_ARTENUMREF_SagId, item.ComArt_F_CONDITION_SagId);
if (F_ARTICLE_Composition != null)
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(item.ComArt_F_ARTICLE_SagId);
Model.Prestashop.PsProductAttributeRepository PsProductAttributeRepository = new Model.Prestashop.PsProductAttributeRepository();
Model.Prestashop.PsProductAttribute PsProductAttributeComposition = new Model.Prestashop.PsProductAttribute();
Boolean isProductAttribute = false;
if (item.Pre_Id != null && PsProductAttributeRepository.ExistProductAttribute((uint)item.Pre_Id))
{
PsProductAttributeComposition = PsProductAttributeRepository.ReadProductAttribute((uint)item.Pre_Id);
if (PsProductAttributeComposition != null)
{
isProductAttribute = true;
}
}
if (isProductAttribute == true)
{
int CatComptaArticle = Core.Global.GetConfig().ConfigArticleCatComptable;
Model.Sage.F_TAXE TaxeTVA = SynchronisationArticle.ReadTaxe(F_ARTICLE, Product, CatComptaArticle);
Model.Prestashop.PsProduct temp_product = new Model.Prestashop.PsProduct();
temp_product.taxe_famillesage = Product.taxe_famillesage;
// temp_product sert pour conserver l'information "ecoraxeht_sage" pour la fonction SpecificPrice
Model.Sage.F_TAXE TaxeEco = SynchronisationArticle.ReadEcoTaxe(F_ARTICLE, temp_product, TaxeTVA, CatComptaArticle);
PsProductAttributeComposition.EcOtAx = temp_product.EcOtAx;
if (F_ARTICLE_Composition.F_CONDITION_SagId == null && F_ARTICLE_Composition.F_ARTENUMREF_SagId == null)
{
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeight(F_ARTICLE, PsProductAttributeComposition);
}
SynchronisationArticle.ReadQuantity(F_ARTICLE, PsProductAttributeComposition);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPrice(F_ARTICLE, PsProductAttributeComposition, TaxeTVA);
}
//List<string> log;
//this.ExecSpecificPrice(F_ARTICLE, Product, Article.Art_Id, TaxeTVA, TaxeEco, out log);
//if (log != null && log.Count > 0)
// log_chrono.AddRange(log);
}
else if (F_ARTICLE_Composition.F_ARTENUMREF_SagId != null)
{
Model.Prestashop.PsProduct temp_product_f_artenumref = new Model.Prestashop.PsProduct();
// lecture des valeurs pour F_ARTICLE
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeight(F_ARTICLE, temp_product_f_artenumref);
}
SynchronisationArticle.ReadQuantity(F_ARTICLE, temp_product_f_artenumref);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPrice(F_ARTICLE, temp_product_f_artenumref, TaxeTVA);
}
// transformation en fonction de f_artenumref
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeightAttribute(temp_product_f_artenumref, PsProductAttributeComposition, F_ARTICLE, item.EnumereGamme1);
PsProductAttributeComposition.Weight += temp_product_f_artenumref.Weight;
}
SynchronisationArticle.ReadQuantityAttribute(PsProductAttributeComposition, F_ARTICLE, item.EnumereGamme1, item.EnumereGamme2);
//SynchronisationArticle.ReadRefEANAttribute(PsProductAttributeComposition, F_ARTICLE, item.EnumereGamme1, item.EnumereGamme2);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPriceAttribute(temp_product_f_artenumref, PsProductAttributeComposition, F_ARTICLE, item.EnumereGamme1, item.EnumereGamme2, TaxeTVA);
}
PsProductAttributeComposition.Price += temp_product_f_artenumref.Price;
}
else if (F_ARTICLE_Composition.F_CONDITION_SagId != null)
{
Model.Prestashop.PsProduct temp_product_f_condition = new Model.Prestashop.PsProduct();
// lecture des valeurs pour F_ARTICLE
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeight(F_ARTICLE, temp_product_f_condition);
}
SynchronisationArticle.ReadQuantity(F_ARTICLE, temp_product_f_condition);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPrice(F_ARTICLE, temp_product_f_condition, TaxeTVA);
}
// transformation en fonction de F_CONDITION
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeightConditioning(temp_product_f_condition, PsProductAttributeComposition, item.EnumereF_CONDITION);
PsProductAttributeComposition.Weight += temp_product_f_condition.Weight;
}
SynchronisationArticle.ReadQuantityConditioning(PsProductAttributeComposition, F_ARTICLE, item.EnumereF_CONDITION);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPriceConditioning(temp_product_f_condition, PsProductAttributeComposition, F_ARTICLE, item.EnumereF_CONDITION, TaxeTVA);
}
PsProductAttributeComposition.Price += temp_product_f_condition.Price;
}
//PsProductAttributeComposition.DefaultOn = (item.ComArt_Default) ? (byte)1 : (byte)0;
PsProductAttributeRepository.Save();
SynchronisationArticle.ExecShopProductAttribute(PsProductAttributeComposition);
SynchronisationArticle.WriteStockAvailableComposition(Product, PsProductAttributeComposition);
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
// prix spécifiques
temp_product.Price = PsProductAttributeComposition.Price;
temp_product.IDProduct = Product.IDProduct;
List <string> log;
SynchronisationArticle.ExecSpecificPrice(F_ARTICLE, temp_product, Article, item, TaxeTVA, TaxeEco, out log);
if (log != null && log.Count > 0)
{
SynchronisationArticle.log_chrono.AddRange(log);
}
}
}
}
}
catch (Exception ex) { Core.Error.SendMailError(ex.ToString()); }
}
}
private void ExecConditioning(Model.Local.Article Article, Model.Prestashop.PsProduct PsProduct, Model.Sage.F_TAXE TaxeTVA, Model.Prestashop.PsProductRepository PsProductRepository)
{
try
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(Article.Sag_Id);
Model.Local.ConditioningGroupRepository ConditioningGroupRepository = new Model.Local.ConditioningGroupRepository();
Model.Prestashop.PsAttributeGroupRepository PsAttributeGroupRepository = new Model.Prestashop.PsAttributeGroupRepository();
Boolean isProductAttribute;
if (F_ARTICLE.AR_Condition != null && F_ARTICLE.AR_Condition != 0 &&
ConditioningGroupRepository.ExistSage((int)F_ARTICLE.AR_Condition) &&
PsAttributeGroupRepository.ExistAttributeGroup((uint)ConditioningGroupRepository.ReadSage((int)F_ARTICLE.AR_Condition).Pre_Id))
{
Model.Local.ConditioningArticleRepository ConditioningArticleRepository = new Model.Local.ConditioningArticleRepository();
List <Model.Local.ConditioningArticle> ListConditioningArticle = ConditioningArticleRepository.ListArticleSync(Article.Art_Id, true);
Model.Prestashop.PsProductAttributeRepository PsProductAttributeRepository = new Model.Prestashop.PsProductAttributeRepository();
Model.Prestashop.PsProductAttribute PsProductAttribute;
int stockmaxunity = 0;
foreach (Model.Local.ConditioningArticle ConditioningArticle in ListConditioningArticle)
{
if (ConditioningArticle.EnumereF_CONDITION != null)
{
PsProductAttribute = new Model.Prestashop.PsProductAttribute();
isProductAttribute = false;
if (ConditioningArticle.Pre_Id != null && ConditioningArticle.Pre_Id != 0)
{
if (PsProductAttributeRepository.ExistProductAttribute((UInt32)ConditioningArticle.Pre_Id))
{
PsProductAttribute = PsProductAttributeRepository.ReadProductAttribute((UInt32)ConditioningArticle.Pre_Id);
isProductAttribute = true;
}
}
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeightConditioning(PsProduct, PsProductAttribute, ConditioningArticle.EnumereF_CONDITION);
}
SynchronisationArticle.ReadQuantityConditioning(PsProductAttribute, F_ARTICLE, ConditioningArticle.EnumereF_CONDITION);
if (Core.Global.GetConfig().LimiteStockConditionnement&& PsProductAttribute.Quantity >= stockmaxunity)
{
stockmaxunity = PsProductAttribute.Quantity;
PsProduct.Quantity = stockmaxunity;
PsProductRepository.Save();
}
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPriceConditioning(PsProduct, PsProductAttribute, F_ARTICLE, ConditioningArticle.EnumereF_CONDITION, TaxeTVA);
}
//PsProductAttribute.DefaultOn = (ConditioningArticle.ConArt_Default) ? (byte)1 : (byte)0;
if (isProductAttribute == true)
{
PsProductAttributeRepository.Save();
SynchronisationArticle.ExecShopProductAttribute(PsProductAttribute);
SynchronisationArticle.WriteStockAvailableProductAttribute(PsProduct, PsProductAttribute);
}
}
}
PsProductAttributeRepository.WriteDate(PsProduct.IDProduct);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
private void ExecAttribute(Model.Local.Article Article, Model.Prestashop.PsProduct PsProduct, Model.Sage.F_TAXE TaxeTVA, Model.Prestashop.PsProductRepository PsProductRepository)
{
try
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(Article.Sag_Id);
Model.Local.AttributeGroupRepository AttributeGroupRepository = new Model.Local.AttributeGroupRepository();
Model.Prestashop.PsAttributeGroupRepository PsAttributeGroupRepository = new Model.Prestashop.PsAttributeGroupRepository();
Boolean isProductAttribute;
if (F_ARTICLE.AR_Gamme1 != null && F_ARTICLE.AR_Gamme1 != 0 &&
AttributeGroupRepository.ExistSage((int)F_ARTICLE.AR_Gamme1) &&
PsAttributeGroupRepository.ExistAttributeGroup((uint)AttributeGroupRepository.ReadSage((int)F_ARTICLE.AR_Gamme1).Pre_Id) &&
((F_ARTICLE.AR_Gamme2 == null || F_ARTICLE.AR_Gamme2 == 0) ||
(AttributeGroupRepository.ExistSage((int)F_ARTICLE.AR_Gamme2) &&
PsAttributeGroupRepository.ExistAttributeGroup((uint)AttributeGroupRepository.ReadSage((int)F_ARTICLE.AR_Gamme2).Pre_Id))))
{
Model.Local.AttributeArticleRepository AttributeArticleRepository = new Model.Local.AttributeArticleRepository();
List <Model.Local.AttributeArticle> ListAttributeArticle = AttributeArticleRepository.ListArticleSync(Article.Art_Id, true);
Model.Prestashop.PsProductAttributeRepository PsProductAttributeRepository = new Model.Prestashop.PsProductAttributeRepository();
Model.Prestashop.PsProductAttribute PsProductAttribute;
int CumulStockGammes = 0;
foreach (Model.Local.AttributeArticle AttributeArticle in ListAttributeArticle)
{
if (AttributeArticle.EnumereF_ARTENUMREF != null)
{
PsProductAttribute = new Model.Prestashop.PsProductAttribute();
isProductAttribute = false;
if (AttributeArticle.Pre_Id != null && AttributeArticle.Pre_Id != 0)
{
if (PsProductAttributeRepository.ExistProductAttribute((UInt32)AttributeArticle.Pre_Id))
{
PsProductAttribute = PsProductAttributeRepository.ReadProductAttribute((UInt32)AttributeArticle.Pre_Id);
isProductAttribute = true;
}
}
if (isProductAttribute == true)
{
if (Core.Global.GetConfig().MajPoidsSynchroStock)
{
SynchronisationArticle.ReadWeightAttribute(PsProduct, PsProductAttribute, F_ARTICLE, AttributeArticle.EnumereGamme1);
}
SynchronisationArticle.ReadQuantityAttribute(PsProductAttribute, F_ARTICLE, AttributeArticle.EnumereGamme1, AttributeArticle.EnumereGamme2);
CumulStockGammes += PsProductAttribute.Quantity;
// <JG> 03/06/2016
if (Article.Art_SyncPrice)
{
SynchronisationArticle.ReadPriceAttribute(PsProduct, PsProductAttribute, F_ARTICLE, AttributeArticle.EnumereGamme1, AttributeArticle.EnumereGamme2, TaxeTVA);
}
PsProductAttributeRepository.Save();
SynchronisationArticle.ExecShopProductAttribute(PsProductAttribute);
SynchronisationArticle.WriteStockAvailableProductAttribute(PsProduct, PsProductAttribute);
}
}
}
if (PsProduct.Quantity != CumulStockGammes)
{
PsProduct.Quantity = CumulStockGammes;
PsProductRepository.Save();
}
PsProductAttributeRepository.WriteDate(PsProduct.IDProduct);
}
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void Exec(Int32 ProductSend)
{
try
{
Model.Local.ArticleRepository ArticleRepository = new Model.Local.ArticleRepository();
if (ArticleRepository.ExistPre_Id(ProductSend) == false)
{
Model.Prestashop.PsProductLangRepository PsProductLangRepository = new Model.Prestashop.PsProductLangRepository();
if (PsProductLangRepository.ExistProductLang(ProductSend, Global.Lang, Global.CurrentShop.IDShop))
{
Model.Prestashop.PsProductRepository PsProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct PsProduct = PsProductRepository.ReadId(Convert.ToUInt32(ProductSend));
Model.Prestashop.PsProductLang PsProductLang = PsProductLangRepository.ReadProductLang(ProductSend, Global.Lang, Global.CurrentShop.IDShop);
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
string product_reference = PsProduct.Reference;
product_reference = product_reference.Replace(" ", "_");
if (F_ARTICLERepository.ExistReference(product_reference))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadReference(product_reference);
Model.Local.Article Article = new Model.Local.Article()
{
Art_Name = PsProductLang.Name,
Art_Description = PsProductLang.Description,
Art_Description_Short = PsProductLang.DescriptionShort,
Art_LinkRewrite = PsProductLang.LinkRewrite,
Art_MetaTitle = PsProductLang.MetaTitle,
Art_MetaKeyword = PsProductLang.MetaKeywords,
Art_MetaDescription = PsProductLang.MetaDescription,
Art_Ref = PsProduct.Reference,
Art_Ean13 = PsProduct.EAn13,
Art_Pack = PsProduct.CacheIsPack == 1,
Art_Solde = Convert.ToBoolean(PsProduct.OnSale),
Art_Active = Convert.ToBoolean(PsProduct.Active),
Art_Sync = true,
Art_SyncPrice = true,
Art_Date = (PsProduct.DateUpd != null && PsProduct.DateUpd > new DateTime(1753, 1, 2)) ? PsProduct.DateUpd : DateTime.Now.Date,
Sag_Id = F_ARTICLE.cbMarq,
Pre_Id = Convert.ToInt32(PsProduct.IDProduct),
Cat_Id = this.ReadCatalog(PsProduct.IDCategoryDefault),
Art_RedirectType = new Model.Internal.RedirectType(Core.Parametres.RedirectType.NoRedirect404).Page,
Art_RedirectProduct = 0,
Art_Manufacturer = (PsProduct.IDManufacturer != null) ? (int)PsProduct.IDManufacturer : 0,
Art_Supplier = (PsProduct.IDSupplier != null) ? (int)PsProduct.IDSupplier : 0,
};
if (Article.Cat_Id == 0)
{
foreach (Model.Prestashop.PsCategoryProduct PsCategoryProduct in new Model.Prestashop.PsCategoryProductRepository().ListProduct(PsProduct.IDProduct))
{
Article.Cat_Id = this.ReadCatalog(PsCategoryProduct.IDCategory);
if (Article.Cat_Id != 0)
{
break;
}
}
}
if (PsProduct.CacheIsPack == 1)
{
Article.Art_Pack = true;
}
if (Article.Cat_Id != 0)
{
ArticleRepository.Add(Article);
RecoveryChildData(Article, PsProduct, ArticleRepository, false);
}
}
}
}
else
{
Model.Local.Article Article = ArticleRepository.ReadPre_Id(ProductSend);
Model.Prestashop.PsProductRepository PsProductRepository = new Model.Prestashop.PsProductRepository();
Model.Prestashop.PsProduct PsProduct = PsProductRepository.ReadId(Convert.ToUInt32(ProductSend));
RecoveryChildData(Article, PsProduct, ArticleRepository, true);
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
public void ExecShopProduct(Model.Prestashop.PsProduct PsProduct)
{
Model.Prestashop.PsProductShopRepository PsProductShopRepository = new Model.Prestashop.PsProductShopRepository();
//Si le produit n'existe pas dans la boutique, il est rajouté.
if (!PsProductShopRepository.ExistProductShop(PsProduct.IDProduct, Core.Global.CurrentShop.IDShop))
{
//PsProductShopRepository.Add(new Model.Prestashop.PsProductShop()
//{
// Active = PsProduct.Active,
// AdditionalShippingCost = PsProduct.AdditionalShippingCost,
// AdvancedStockManagement = PsProduct.AdvancedStockManagement,
// AvailableDate = PsProduct.AvailableDate,
// AvailableForOrder = PsProduct.AvailableForOrder,
// CacheDefaultAttribute = PsProduct.CacheDefaultAttribute,
// Customizable = PsProduct.Customizable,
// DateAdd = PsProduct.DateAdd,
// DateUpd = PsProduct.DateUpd,
// EcOtAx = PsProduct.EcOtAx,
// IDCategoryDefault = PsProduct.IDCategoryDefault,
// IDProduct = PsProduct.IDProduct,
// IDShop = Core.Global.CurrentShop.IDShop,
// IDTaxRulesGroup = PsProduct.IDTaxRulesGroup,
// Indexed = PsProduct.Indexed,
// MinimalQuantity = PsProduct.MinimalQuantity,
// OnlineOnly = PsProduct.OnlineOnly,
// OnSale = PsProduct.OnSale,
// Price = PsProduct.Price,
// ShowPrice = PsProduct.ShowPrice,
// TextFields = PsProduct.TextFields,
// UnitPriceRatio = PsProduct.UnitPriceRatio,
// Unity = PsProduct.Unity,
// UploadAbleFiles = PsProduct.UploadAbleFiles,
// WholesalePrice = PsProduct.WholesalePrice,
//});
}
else
{
Model.Prestashop.PsProductShop PsProductShop = PsProductShopRepository.ReadProductShop(PsProduct.IDProduct, Core.Global.CurrentShop.IDShop);
//PsProductShop.Active = PsProduct.Active;
//PsProductShop.AdditionalShippingCost = PsProduct.AdditionalShippingCost;
//PsProductShop.AdvancedStockManagement = PsProduct.AdvancedStockManagement;
//PsProductShop.AvailableDate = PsProduct.AvailableDate;
//PsProductShop.AvailableForOrder = PsProduct.AvailableForOrder;
//PsProductShop.CacheDefaultAttribute = PsProduct.CacheDefaultAttribute;
//PsProductShop.Customizable = PsProduct.Customizable;
//PsProductShop.DateAdd = PsProduct.DateAdd;
//PsProductShop.DateUpd = PsProduct.DateUpd;
//PsProductShop.EcOtAx = PsProduct.EcOtAx;
PsProductShop.IDCategoryDefault = PsProduct.IDCategoryDefault;
//PsProductShop.IDTaxRulesGroup = PsProduct.IDTaxRulesGroup;
//PsProductShop.Indexed = PsProduct.Indexed;
//PsProductShop.MinimalQuantity = PsProduct.MinimalQuantity;
//PsProductShop.OnlineOnly = PsProduct.OnlineOnly;
//PsProductShop.OnSale = PsProduct.OnSale;
//PsProductShop.Price = PsProduct.Price;
//PsProductShop.ShowPrice = PsProduct.ShowPrice;
//PsProductShop.TextFields = PsProduct.TextFields;
//PsProductShop.UnitPriceRatio = PsProduct.UnitPriceRatio;
//PsProductShop.Unity = PsProduct.Unity;
//PsProductShop.UploadAbleFiles = PsProduct.UploadAbleFiles;
//PsProductShop.WholesalePrice = PsProduct.WholesalePrice;
PsProductShopRepository.Save();
}
}
private void ExecLocalToDistant(Model.Local.Article Article, Model.Local.ArticleRepository ArticleRepository, Model.Prestashop.PsProduct Product, Model.Prestashop.PsProductRepository ProductRepository)
{
try
{
Model.Sage.F_ARTICLERepository F_ARTICLERepository = new Model.Sage.F_ARTICLERepository();
if (F_ARTICLERepository.ExistArticle(Article.Sag_Id))
{
Model.Sage.F_ARTICLE F_ARTICLE = F_ARTICLERepository.ReadArticle(Article.Sag_Id);
Model.Prestashop.PsPackRepository PsPackRepository = new Model.Prestashop.PsPackRepository();
List <Model.Prestashop.PsPack> ListPsPack = PsPackRepository.ListProductPack(Product.IDProduct);
foreach (Model.Prestashop.PsPack PsPack in ListPsPack)
{
PsPackRepository.Delete(PsPack);
}
#region Pack/nomenclature
if (Article.Art_Pack == true)
{
Model.Sage.F_NOMENCLATRepository F_NOMENCLATRepository = new Model.Sage.F_NOMENCLATRepository();
List <Model.Sage.F_NOMENCLAT> ListF_NOMENCLAT = F_NOMENCLATRepository.ListRef(F_ARTICLE.AR_Ref);
Model.Sage.F_ARTICLE F_ARTICLENOMENCLAT;
Model.Local.Article ArticleNomenclat;
Model.Prestashop.PsPack PsPackAdd;
foreach (Model.Sage.F_NOMENCLAT F_NOMENCLAT in ListF_NOMENCLAT)
{
if (F_ARTICLERepository.ExistReference(F_NOMENCLAT.NO_RefDet))
{
F_ARTICLENOMENCLAT = F_ARTICLERepository.ReadReference(F_NOMENCLAT.NO_RefDet);
if (ArticleRepository.ExistSag_Id(F_ARTICLENOMENCLAT.cbMarq) &&
F_ARTICLENOMENCLAT.AR_SuiviStock != (short)ABSTRACTION_SAGE.F_ARTICLE.Obj._Enum_AR_SuiviStock.Aucun)
// pour ne pas prendre en compte les articles non suivi en stock
{
ArticleNomenclat = ArticleRepository.ReadSag_Id(F_ARTICLENOMENCLAT.cbMarq);
if (ArticleNomenclat.Pre_Id != null && ArticleNomenclat.Pre_Id.Value != 0)
{
if (ProductRepository.ExistId((UInt32)ArticleNomenclat.Pre_Id.Value))
{
PsPackAdd = new Model.Prestashop.PsPack()
{
IDProductPack = Product.IDProduct,
IDProductItem = (UInt32)ArticleNomenclat.Pre_Id.Value,
Quantity = (UInt32)F_NOMENCLAT.NO_Qte.Value
};
PsPackRepository.Add(PsPackAdd);
}
}
}
}
}
}
#endregion
}
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
private void ExecDistantToLocal(Model.Prestashop.PsProduct Product, Model.Local.Article Article, Model.Local.ArticleRepository ArticleRepository)
{
try
{
#region Recovery Data From CategoryProduct
Model.Prestashop.PsCategoryProductRepository PsCategoryProductRepository = new Model.Prestashop.PsCategoryProductRepository();
Model.Local.CatalogRepository CatalogRepository = new Model.Local.CatalogRepository();
Model.Local.ArticleCatalogRepository ArticleCatalogRepository = new Model.Local.ArticleCatalogRepository();
Model.Prestashop.PsCategoryRepository PsCategoryRepository = new Model.Prestashop.PsCategoryRepository();
// filtrage des catalogues existants dans PC et PS
List <Model.Local.CatalogLight> ListLocalCatalog = CatalogRepository.ListLight();
List <uint> ListPrestashopCategory = PsCategoryRepository.ListIdOrderByLevelDepth(Core.Global.CurrentShop.IDShop, PsCategoryRepository.ReadId(Core.Global.CurrentShop.IDCategory).LevelDepth);
ListLocalCatalog = ListLocalCatalog.Where(lc => ListPrestashopCategory.Count(pc => pc == (uint)lc.Pre_Id) > 0).ToList();
// filtrage des associations PS par rapport aux catégories PS existantes en tant que catalogue PC
List <Model.Prestashop.PsCategoryProduct> ListPsCategoryProduct = PsCategoryProductRepository.ListProduct(Product.IDProduct);
ListPsCategoryProduct = ListPsCategoryProduct.Where(cp => ListLocalCatalog.Count(lc => lc.Pre_Id == cp.IDCategory) > 0).ToList();
// filtrage des associations PC par rapport aux catégories ayant un ID PS
List <Model.Local.ArticleCatalog> ListLocal = ArticleCatalogRepository.ListArticle(Article.Art_Id);
ListLocal = ListLocal.Where(ac => ac.Catalog.Pre_Id != null).ToList();
// tant que les associations en local contiennent des associations non présentes dans Prestashop
if (Core.Global.GetConfig().DeleteCatalogProductAssociation)
{
// suppression des occurences inexistantes dans PS
while (ListLocal.Count(ac => ListPsCategoryProduct.Count(cp => cp.IDCategory == ac.Catalog.Pre_Id) == 0) > 0)
{
Model.Local.ArticleCatalog target = ListLocal.FirstOrDefault(ac => ListPsCategoryProduct.Count(cp => cp.IDCategory == ac.Catalog.Pre_Id) == 0);
ArticleCatalogRepository.Delete(target);
ListLocal.Remove(target);
}
;
}
// récupération catégorie principale si catalogue existant dans Prestaconnect
if (Product.IDCategoryDefault != null && Product.IDCategoryDefault != 0 &&
ListLocalCatalog.Count(lc => lc.Pre_Id == (int)Product.IDCategoryDefault) > 0)
{
ArticleRepository = new Model.Local.ArticleRepository();
Article = ArticleRepository.ReadArticle(Article.Art_Id);
Article.Cat_Id = ListLocalCatalog.FirstOrDefault(lc => lc.Pre_Id == (int)Product.IDCategoryDefault).Cat_Id;
ArticleRepository.Save();
if (ListLocal.Count(ac => ac.Art_Id == Article.Art_Id && ac.Cat_Id == Article.Cat_Id) == 0)
{
ArticleCatalogRepository.Add(new Model.Local.ArticleCatalog()
{
Art_Id = Article.Art_Id,
Cat_Id = Article.Cat_Id
});
}
}
// filtre des associations Prestashop par rapport à celles déjà présentes dans Prestaconnect puis ajout
ListLocal = ArticleCatalogRepository.ListArticle(Article.Art_Id);
ListLocal = ListLocal.Where(ac => ac.Catalog.Pre_Id != null).ToList();
ListPsCategoryProduct = ListPsCategoryProduct.Where(cp => ListLocal.Count(ac => ac.Catalog.Pre_Id == (Int32)cp.IDCategory) == 0).ToList();
foreach (Model.Prestashop.PsCategoryProduct PsCategoryProduct in ListPsCategoryProduct)
{
ArticleCatalogRepository.Add(new Model.Local.ArticleCatalog()
{
Art_Id = Article.Art_Id,
Cat_Id = ListLocalCatalog.FirstOrDefault(lc => lc.Pre_Id == (Int32)PsCategoryProduct.IDCategory).Cat_Id
});
}
#endregion
}
catch (Exception ex)
{
Core.Error.SendMailError(ex.ToString());
}
}
