예제 #1
0
        public async Task <IActionResult> PutSousCategorie(Guid id, SousCategorie sousCategorie)
        {
            if (id != sousCategorie.IdScat)
            {
                return(BadRequest());
            }

            _context.Entry(sousCategorie).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SousCategorieExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
예제 #2
0
 public ActionResult Delete(String id, SousCategorie p)
 {
     p = es.GetById(id);
     es.Delete(p);
     es.Commit();
     return(RedirectToAction("listeSouscategorie"));
 }
예제 #3
0
        public async Task <ActionResult <string> > Put(SousCategorie sc)
        {
            var comm   = new UpdateCommandGeneric <SousCategorie>(sc);
            var result = await _mediator.Send(comm);

            return(Ok(result));
        }
예제 #4
0
        public ActionResult ModifierComp(int id, string nom, DateTime dateD, DateTime dateF, string type, string nbrJ, int idc)
        {
            SousCategorie        sc  = new SousCategorie();
            List <SousCategorie> lSC = new List <SousCategorie>();

            lSC = sc.GetList(idc);
            List <CPays> listePays = new CPays().GetListPays();

            listePays.Insert(0, (CPays)Session["CPays"]);
            List <String> listeType = new List <String>();

            listeType.Add(type);
            listeType.Add("Masculin");
            listeType.Add("Féminin");
            listeType.Add("Mixte");
            List <String> listeNbrJ = new List <String>();

            listeNbrJ.Add(nbrJ);
            listeNbrJ.Add("Individuel");
            listeNbrJ.Add("Equipe");
            ViewBag.listeSC   = new SelectList(lSC, "Id", "Nom");
            ViewBag.listePays = new SelectList(listePays, "Id", "Pays");
            ViewBag.listeType = new SelectList(listeType);
            ViewBag.listeNbrJ = new SelectList(listeNbrJ);
            ViewBag.Nom       = nom;
            ViewBag.dateD     = dateD;
            ViewBag.dateF     = dateF;
            ViewBag.idComp    = id;
            return(View());
        }
예제 #5
0
        /// <summary>
        /// Ajoute une sous catégorie provenant de l'outil s de restauration
        /// </summary>
        /// <param name="sousCategorie">la sous catégorie à ajouter</param>
        /// <returns>la task</returns>
        public async Task AjouterSousCategorieFmRestauration(SousCategorie sousCategorie)
        {
            sousCategorie.IsSousCategPerso = true;
            await Bdd.AjouterDonnee(sousCategorie);

            await RoamingCategorieBusiness.AjouterSousCategorie(sousCategorie);
        }
예제 #6
0
        public async Task <ActionResult <SousCategorie> > PostSousCategorie(SousCategorie sousCategorie)
        {
            _context.SousCategories.Add(sousCategorie);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetSousCategorie", new { id = sousCategorie.IdScat }, sousCategorie));
        }
예제 #7
0
        /// <summary>
        /// Supprime une sous catégorie
        /// </summary>
        /// <param name="sousCategorie">La sous categorie à supprimer</param>
        /// <returns>la task</returns>
        public static async Task SupprimerSousCategorie(SousCategorie sousCategorie)
        {
            await DemarrageRoaming();

            _roamingCategorie.ListeSousCategorie.RemoveAll(x => x.Id == sousCategorie.Id);
            await SaveFile();
        }
예제 #8
0
        /// <summary>
        /// modifie une sous catégorie
        /// </summary>
        /// <param name="sousCategorie">la sous catégorie à modifier</param>
        /// <returns>la task</returns>
        public static async Task ModifierSousCategorie(SousCategorie sousCategorie)
        {
            await DemarrageRoaming();

            _roamingCategorie.ListeSousCategorie.First(x => x.Id == sousCategorie.Id).Libelle = sousCategorie.Libelle;
            await SaveFile();
        }
예제 #9
0
        /// <summary>
        /// Ajoute une sous catégorie au roaming
        /// </summary>
        /// <param name="sousCategorie">la sous catégorie à ajouter</param>
        /// <returns>la task</returns>
        public static async Task AjouterSousCategorie(SousCategorie sousCategorie)
        {
            await DemarrageRoaming();

            _roamingCategorie.ListeSousCategorie.Add(sousCategorie);
            await SaveFile();
        }
예제 #10
0
        public ActionResult SousCategorie(int id)
        {
            Session["idC"] = id;
            SousCategorie Scat = new SousCategorie();
            Categorie     cat  = new DCCategorie().find(id);

            ViewBag.Cat     = cat;
            ViewBag.sousCat = Scat.GetList(id);
            return(View());
        }
예제 #11
0
        private void SupprimerSousCategorie(object sender, RoutedEventArgs e)
        {
            SousCategorie selection = (SousCategorie)lvSousCategorie.SelectedItem;

            if (selection != null)
            {
                if (MessageBox.Show($"Etes-vous sur de vouloir supprimer la sous categorie {selection.Nom} de la liste ?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
                {
                    Statics.TryCatch(() => { _bdd.SupprimerSousCategorie(selection); }, nameof(SupprimerSousCategorie));
                }
            }
        }
예제 #12
0
        /// <summary>
        /// modifie une sous categorie
        /// </summary>
        /// <param name="sousCategorie"> l'id de la sous catégorie à modifier</param>
        /// <returns>la task</returns>
        public async Task ModifierSousCategorie(SousCategorie sousCategorie)
        {
            var sousCategToModif =
                await Bdd.Connection.Table <SousCategorie>().Where(x => x.Id == sousCategorie.Id).FirstOrDefaultAsync();

            sousCategToModif.IdCategorie = sousCategorie.IdCategorie;
            sousCategToModif.Libelle     = sousCategorie.Libelle;

            await Bdd.UpdateDonnee(sousCategToModif);

            await RoamingCategorieBusiness.ModifierSousCategorie(sousCategToModif);
        }
예제 #13
0
 public ActionResult ajoutserSouscategorie(SousCategorie p, HttpPostedFileBase File)
 {
     if (!ModelState.IsValid || File == null || File.ContentLength == 0)
     {
         RedirectToAction("ajoutserSouscategorie");
     }
     es.Add(new SousCategorie {
         nomC         = p.nomC,
         categorie_FK = p.categorie_FK
     });
     es.Commit();
     return(RedirectToAction("ajoutserSouscategorie"));
 }
예제 #14
0
        /// <summary>
        /// Masque ou démasque une sous catégorie
        /// </summary>
        /// <param name="sousCateg">la sous catégorie dont on souhaite changer l'état</param>
        /// <param name="toHide">true si elle doit être masqué</param>
        /// <returns></returns>
        public async Task HideUnhideSousCateg(SousCategorie sousCateg, bool toHide)
        {
            //met à jour la sous catégorie
            foreach (var category in ContexteAppli.ListeCategoriesMouvement)
            {
                foreach (var sousCategory in category.SousCategorieList)
                {
                    if (sousCategory.Id == sousCateg.Id)
                    {
                        sousCategory.IsHidden = toHide;
                    }
                }
            }

            //recupère tout les id à masquer
            var newListeId = "";

            foreach (var category in ContexteAppli.ListeCategoriesMouvement)
            {
                foreach (var sousCategory in category.SousCategorieList)
                {
                    if (sousCategory.IsHidden)
                    {
                        newListeId += sousCategory.Id + ",";
                    }
                }
            }

            if (newListeId.EndsWith(","))
            {
                newListeId = newListeId.Remove(newListeId.Length - 1, 1);
            }

            //met à jour la liste en base
            await _categorieBusiness.ChangeVisibleSousCateg(newListeId);

            //met à jour l'affichage
            GenererListeCategories();
        }
예제 #15
0
        /// <summary>
        /// Créer une sous catégorie perso
        /// </summary>
        /// <param name="libelle">le libelle de la sous catégorie</param>
        /// <param name="idCategorie">l'id de la catégorie mère</param>
        /// <param name="isCategoriePerso">si la catégorie mère est perso ou non</param>
        /// <returns>la sous catégorie de créer</returns>
        public async Task <SousCategorie> AddSousCategorie(string libelle, int idCategorie, bool isCategoriePerso)
        {
            var sousCategorie = new SousCategorie();
            var sousCategId   = await Bdd.Connection.Table <SousCategorie>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();

            var id = 1;

            if (sousCategId != null)
            {
                id = sousCategId.Id + 1;
            }
            sousCategorie.Id               = id;
            sousCategorie.Libelle          = libelle;
            sousCategorie.IdCategorie      = idCategorie;
            sousCategorie.IsCategPerso     = isCategoriePerso;
            sousCategorie.IsSousCategPerso = true;

            await Bdd.AjouterDonnee(sousCategorie);

            await RoamingCategorieBusiness.AjouterSousCategorie(sousCategorie);

            return(sousCategorie);
        }