public async Task <CommandeFournisseurLigneEntity> DeleteAsync(CommandeFournisseurLigneEntity item)
        {
            _context.Remove(item);
            await _context.SaveChangesAsync();

            return(item);
        }
        public async Task <CommandeFournisseurLigneEntity> AddAsync(CommandeFournisseurLigneEntity item)
        {
            _context.CommandeFournisseurLigneEntities.Add(item);
            await _context.SaveChangesAsync();

            return(item);
        }
 public async Task <CommandeFournisseurLigneEntity> Update(CommandeFournisseurLigneEntity item)
 {
     if (!_repository.Exist(item.Id))
     {
         throw new NotFoundException(ExceptionMessageUtil.NOT_FOUND);
     }
     return(await _repository.UpdateAsync(item));
 }
        public async Task <IActionResult> UpdateLigneQuantite(int CommandeFournisseurId, int LigneQuantite, int LigneId)
        {
            CommandeFournisseurLigneEntity ligne = await _service_commande_fournisseur_ligne.GetOneById(LigneId);

            ligne.Quantite = LigneQuantite;

            await _service_commande_fournisseur_ligne.Update(ligne);

            return(RedirectToAction("Edit", new { Id = CommandeFournisseurId }));
        }
        public async Task <CommandeFournisseurLigneEntity> AddArticle(CommandeFournisseurEntity commande_fournisseur, ArticleEntity article, int article_quantite)
        {
            foreach (CommandeFournisseurLigneEntity l in commande_fournisseur.CommandeFournisseurLignes)
            {
                if (l.ArticleId == article.Id)
                {
                    l.Quantite = l.Quantite + article_quantite;
                    return(await Update(l));
                }
            }

            CommandeFournisseurLigneEntity ligne = new CommandeFournisseurLigneEntity();

            ligne.CommandeFournisseurId = commande_fournisseur.Id;
            ligne.ArticleId             = article.Id;
            ligne.Quantite = article_quantite;

            return(await _repository.AddAsync(ligne));
        }
        // Algorithme de determination de creation et envoi de CommandeFournisseur automatisees
        public async Task <List <CommandeFournisseurEntity> > getCommandesFournisseurAuto(CommandeEntity commande)
        {
            if (commande == null)
            {
                throw new NullReferenceException(nameof(commande));
            }

            // liste des references de lignes necessitant un restock
            List <CommandeLigneEntity> lignes_pour_restock = new List <CommandeLigneEntity>();
            // liste des references des Fournisseur impliqués
            List <FournisseurEntity> liste_fournisseurs = new List <FournisseurEntity>();
            // liste finale des CommandeFournisseur automatiques, à enregistrer puis envoyer
            List <CommandeFournisseurEntity> liste_commandes_auto = new List <CommandeFournisseurEntity>();


            foreach (var ligne in commande.CommandeLignes)
            {
                var proj = _service_stock_projection.Value.Projection(ligne.ArticleId).Result;
                Console.WriteLine(proj);
                // si la projection MOINS la quantite souhaitee met en peril le stock (inferieur au seuil de stock minimal parametre : aka. Article.Threshold)
                if ((proj - ligne.Quantite) <= ligne.Article.Threshold)
                {
                    // on reference la ligne en question
                    lignes_pour_restock.Add(ligne);
                    // on reference le Fournisseur isolement, en verifiant qu'il ne soit pas deja reference
                    FournisseurEntity fournisseur = await _service_fournisseur.GetOneById(ligne.Article.FournisseurId);

                    if (!liste_fournisseurs.Contains(fournisseur))
                    {
                        liste_fournisseurs.Add(fournisseur);
                    }
                }
            }

            // si effectivement des lignes de la Commande Client ont ete referencees...
            if (lignes_pour_restock.Count > 0)
            {
                // ... on parcours chaque Fournisseur pour lui attribuer une CommandeFournisseur
                foreach (var fournisseur in liste_fournisseurs)
                {
                    var commande_auto = new CommandeFournisseurEntity();
                    commande_auto.isAuto = true;
                    commande_auto.CommandeFournisseurLignes = new List <CommandeFournisseurLigneEntity>();
                    commande_auto.FournisseurId             = fournisseur.Id; // on lui associe le bon fournisseur, notamment pour l'adresse ; et en general car l'information semble pertinente

                    // on isole les lignes de commande pour ce Fournisseur uniquement, grace a List<T>.FindAll(...conditions...)
                    List <CommandeLigneEntity> lignes_a_traiter = lignes_pour_restock.FindAll(o => o.Article.FournisseurId == fournisseur.Id);

                    foreach (var ligne in lignes_a_traiter)
                    {
                        CommandeFournisseurLigneEntity new_ligne = new CommandeFournisseurLigneEntity();
                        new_ligne.ArticleId = ligne.Article.Id;
                        new_ligne.Quantite  = ligne.Article.Threshold * 2;  //  2 x le seuil // anicennement :: calculateArticleAdvisedQuantity(ligne.Article, projectionPourCalcul);

                        commande_auto.CommandeFournisseurLignes.Add(new_ligne);

                        // enregistrement
                        liste_commandes_auto.Add(commande_auto);
                    }
                }
            }

            return(liste_commandes_auto);
        }