Example #1
0
        public ActionResult Index(int?page, RechercheActiviteViewModel rechercheActivite, int?vientDePagination)
        {
            int nbItemsParPages = 5;

            if (vientDePagination != null && TempData["rechercheActiviteAncienne"] != null)
            {
                rechercheActivite = TempData["rechercheActiviteAncienne"] as RechercheActiviteViewModel;
            }
            else
            {
                page = null;
            }

            if (TempData["rechercheActivite"] != null)
            {
                rechercheActivite = TempData["rechercheActivite"] as RechercheActiviteViewModel;
            }
            if (rechercheActivite == null)
            {
                rechercheActivite = new RechercheActiviteViewModel();
            }

            //Par défaut, on met la recherche d'activité aux activités futurs
            if (rechercheActivite.activiteFuturs == null)
            {
                rechercheActivite.activiteFuturs = true;
            }

            try
            {
                int noMembreCo;
                verifierSiCookieNoMembreExiste(out noMembreCo);

                IQueryable <Activite> listActiviteTrouves = Utilitaires.RechercheActiviteAvecCriteres(noMembreCo, rechercheActivite);

                GestionPagination(page, nbItemsParPages, rechercheActivite.nbActivitesTrouvesTotal);

                rechercheActivite.resultatsActivite = listActiviteTrouves
                                                      .Skip((int)(ViewBag.currentPage - 1) * nbItemsParPages)
                                                      .Take(nbItemsParPages)
                                                      .Include(a => a.listeAvisActivite)
                                                      .Include(a => a.listePhotosActivites)
                                                      .ToList();

                TempData["rechercheActiviteAncienne"] = rechercheActivite;

                if (noMembreCo != -1)
                {
                    Membre membreCo = db.Membres.Where(m => m.noMembre == noMembreCo).FirstOrDefault();
                    if (membreCo != null)
                    {
                        //Si le membre est connecté, et qu'il a déjà envoyé un commentaire, on va le rechercher, sinon on en crée un nouveau.
                        foreach (Activite a in rechercheActivite.resultatsActivite)
                        {
                            AvisActivite avisDuMembreCo = a.listeAvisActivite.Where(m => m.noMembreEnvoyeur == membreCo.noMembre && m.noActiviteAssocie == a.noActivite).FirstOrDefault();
                            if (avisDuMembreCo == null)
                            {
                                AvisActivite nouvelleAvisActivite = new AvisActivite();
                                nouvelleAvisActivite.membreEnvoyeur    = membreCo;
                                nouvelleAvisActivite.noMembreEnvoyeur  = membreCo.noMembre;
                                nouvelleAvisActivite.activiteAssocie   = a;
                                nouvelleAvisActivite.noActiviteAssocie = a.noActivite;

                                a.listeAvisActivite.Add(nouvelleAvisActivite);
                            }
                        }
                    }
                }

                ViewBag.listeThemes = new SelectList(db.Themes, "noTheme", "theme", rechercheActivite.noTheme);

                return(View("Index", rechercheActivite));
            }
            catch (Exception e)
            {
                Dictionary <string, string> parametres = new Dictionary <string, string>()
                {
                    { "Page", page.ToString() }
                };
                throw Utilitaires.templateException("Index", "Activites", "Requête LINQ pour aller chercher les activites des résultats de recherche n'a pas fonctionnée.", e, parametres, "get");
            }
        }
Example #2
0
        public static IQueryable <Activite> RechercheActiviteAvecCriteres(int noMembreCo, RechercheActiviteViewModel rechercheActivite)
        {
            ClubContactContext db = new ClubContactContext();

            IQueryable <Activite> listActiviteTrouves = db.Activites;

            if (noMembreCo != -1)
            {
                Membre leMembreCo = db.Membres.Where(m => m.noMembre == noMembreCo).FirstOrDefault();

                if (leMembreCo != null)
                {
                    //On trouve uniquement les activités compatibles.
                    listActiviteTrouves = listActiviteTrouves
                                          .Where(a => //Si le membre organisateur est le membre connecté, on affiche l'activité...
                                                 (a.noMembreOrganisateur == leMembreCo.noMembre) ? true :
                                                 (
                                                     ((a.hommeSeulement == null ? true : false) || (a.hommeSeulement == leMembreCo.homme)) &&
                                                     ((a.ageMax == null ? true : false) || leMembreCo.age <= a.ageMax) &&
                                                     ((a.ageMin == null ? true : false) || leMembreCo.age >= a.ageMin)
                                                 )
                                                 );

                    //Critères Communs
                    listActiviteTrouves = listActiviteTrouves
                                          .Where(a => //Activites que j'organise
                                                 ((rechercheActivite.organiseParMoi == false ? true : (a.membreOrganisateur.noMembre == noMembreCo))) &&
                                                      //Uniquement ActivitesQueJeParticipe
                                                 ((rechercheActivite.uniquementActivitesQueJeParticipe == false ? true : (a.membresParticipants.Select(m => m.noMembre).Contains((int)noMembreCo)))) &&
                                                      //Ne pas voir les activités dont le membre organisateur nous a dans sa liste noire
                                                 (!a.membreOrganisateur.listeNoire.Select(m => m.noMembre).Contains(leMembreCo.noMembre))
                                                 );
                }
            }

            listActiviteTrouves = listActiviteTrouves
                                  .Where(a => ((rechercheActivite.noTheme == null ? true : false) || a.noTheme == rechercheActivite.noTheme)
                                         );

            //Ne doit pas changé de place, car c'est fait avec les critères
            IQueryable <Activite> listActiviteTrouvesPourDates = listActiviteTrouves
                                                                 .Where(a => (DbFunctions.TruncateTime(DateTime.Now) <= DbFunctions.TruncateTime(a.date))
                                                                        );

            listActiviteTrouves = listActiviteTrouves
                                  .Where(a => ((rechercheActivite.dateRecherche == null ? true : false) || DbFunctions.TruncateTime(a.date) == DbFunctions.TruncateTime(rechercheActivite.dateRecherche)) &&
                                         (rechercheActivite.activiteFuturs == true ? a.date >= DateTime.Now : a.date < DateTime.Now)
                                         );

            IQueryable <Activite> listActiviteTrouvesPreliminaire = listActiviteTrouves
                                                                    .Where(a => ((rechercheActivite.motCle == null ? true : false) || a.nom.ToLower().Contains(rechercheActivite.motCle.ToLower()))
                                                                           );

            if (listActiviteTrouvesPreliminaire.Count() == 0)
            {
                listActiviteTrouves = listActiviteTrouves
                                      .Where(a => ((rechercheActivite.motCle == null ? true : false) || (a.nom.ToLower().Contains(rechercheActivite.motCle.ToLower()) || a.description.ToLower().Contains(rechercheActivite.motCle.ToLower())))
                                             );

                listActiviteTrouvesPourDates = listActiviteTrouvesPourDates
                                               .Where(a => ((rechercheActivite.motCle == null ? true : false) || (a.nom.ToLower().Contains(rechercheActivite.motCle.ToLower()) || a.description.ToLower().Contains(rechercheActivite.motCle.ToLower())))
                                                      );
            }
            else
            {
                listActiviteTrouves = listActiviteTrouvesPreliminaire;

                listActiviteTrouvesPourDates = listActiviteTrouvesPourDates
                                               .Where(a => ((rechercheActivite.motCle == null ? true : false) || a.nom.ToLower().Contains(rechercheActivite.motCle.ToLower()))
                                                      );
            }

            rechercheActivite.datesOuIlYAActivites = listActiviteTrouvesPourDates.Select(m => DbFunctions.TruncateTime(m.date).Value).Distinct().ToList();

            rechercheActivite.nbActivitesTrouvesTotal = listActiviteTrouves.Count();

            if (rechercheActivite.activiteFuturs == true)
            {
                listActiviteTrouves = listActiviteTrouves.OrderBy(m => m.date).ThenBy(a => a.cout).ThenBy(a => a.noActivite);
            }
            else
            {
                listActiviteTrouves = listActiviteTrouves.OrderByDescending(m => m.date).ThenBy(a => a.cout).ThenBy(a => a.noActivite);
            }

            return(listActiviteTrouves);
        }
Example #3
0
        public ActionResult Index(int?page, RechercheActiviteViewModel rechercheActivite, string btnAjoutCommentaire,
                                  List <List <string> > deletePhotos, List <List <HttpPostedFileBase> > fichiersPhotos)
        {
            int noMembreCo;

            verifierSiCookieNoMembreExiste(out noMembreCo);

            if (rechercheActivite.dateRecherche != null)
            {
                if (((DateTime)rechercheActivite.dateRecherche).Date < DateTime.Now.Date)
                {
                    rechercheActivite.activiteFuturs = false;
                }
                else
                {
                    rechercheActivite.activiteFuturs = true;
                }
            }

            int noActiviteModifier;

            if (int.TryParse(btnAjoutCommentaire, out noActiviteModifier))
            {
                int indexActiviteBouton = rechercheActivite.resultatsActivite.FindIndex(a => a.noActivite == noActiviteModifier);

                int indexAvisMembre = rechercheActivite.resultatsActivite[indexActiviteBouton].listeAvisActivite.FindIndex(m => m.noMembreEnvoyeur == noMembreCo);

                if (rechercheActivite.resultatsActivite[indexActiviteBouton].listeAvisActivite[indexAvisMembre].noAvisActivite == 0)
                {
                    db.Entry(rechercheActivite.resultatsActivite[indexActiviteBouton].listeAvisActivite[indexAvisMembre]).State = EntityState.Added;
                }
                else
                {
                    db.Entry(rechercheActivite.resultatsActivite[indexActiviteBouton].listeAvisActivite[indexAvisMembre]).State = EntityState.Modified;
                }

                try
                {
                    db.SaveChanges();
                }
                catch (DbUpdateException e)
                {
                    Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "Mise à jour de la base de données à la suite de l'ajout d'un commentaire à échoué.", e, null, "post"));
                    TempData["rechercheActivite"] = rechercheActivite;

                    TempData["messageErreur"] = "Une erreur est survenu lors de la sauvegarde de votre commentaire, veuillez réessayer.";
                    TempData.Keep();

                    return(RedirectToAction("Index", "Activites", new { page = page }));
                }
            }
            else if (btnAjoutCommentaire == "recherche")
            {
                page = null;
            }
            else if (btnAjoutCommentaire != null)
            {
                if (btnAjoutCommentaire.Contains("photosActivite"))
                {
                    string iString = btnAjoutCommentaire.Remove(0, 14);
                    int    i;
                    if (!int.TryParse(iString, out i))
                    {
                        Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "Parse du int lors de la sauvegarde des photos des activités n'a pas fonctionné, nom photosActivite a peut-être été modifié.", null, null, "post"));
                        TempData["rechercheActivite"] = rechercheActivite;

                        TempData["messageErreur"] = "Une erreur est survenu lors de la sauvegarde de vos photos, veuillez réessayer.";
                        TempData.Keep();

                        return(RedirectToAction("Index", "Activites", new { page = page }));
                    }

                    Activite activiteModifier = TrouverInformationsDActiviteEtAjouterPhotos(rechercheActivite.resultatsActivite[i]);

                    List <PhotosActivite> listeActivitesPhotos = activiteModifier.listePhotosActivites;

                    for (int y = 0; y < listeActivitesPhotos.Count; y++)
                    {
                        if (listeActivitesPhotos[y].noPhotoActivite == 0 && fichiersPhotos[i][y] == null)
                        {
                            db.Entry(listeActivitesPhotos[y]).State = EntityState.Detached;

                            listeActivitesPhotos.RemoveAt(y);
                            deletePhotos[i].RemoveAt(y);
                            fichiersPhotos[i].RemoveAt(y);
                            y--;
                        }
                        else if (listeActivitesPhotos[y].noPhotoActivite == 0)
                        {
                            db.Entry(listeActivitesPhotos[y]).State = EntityState.Added;
                        }
                    }

                    db.Entry(activiteModifier).State = EntityState.Modified;

                    //étape 2
                    for (int y = 0; y < listeActivitesPhotos.Count; y++)
                    {
                        //Si on veut supprimer la photo
                        if (deletePhotos[i].Count > y && deletePhotos[i][y] == "true")
                        {
                            if (listeActivitesPhotos[y].noPhotoActivite == 0)
                            {
                                listeActivitesPhotos.RemoveAt(y);
                                deletePhotos[i].RemoveAt(y);
                                fichiersPhotos[i].RemoveAt(y);
                                y--;
                            }
                            else
                            {
                                var path     = Url.Content("~/Upload/PhotosActivites/" + listeActivitesPhotos[y].nomFichierPhoto);
                                var fullPath = Request.MapPath(path);

                                if (System.IO.File.Exists(fullPath))
                                {
                                    try
                                    {
                                        System.IO.File.Delete(fullPath);
                                    }
                                    catch (Exception e)
                                    {
                                        Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "La suppression de la photo: " + fullPath + " ne s'est pas complété correctement.", e, null, "post"));
                                    }
                                }
                                else
                                {
                                    Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "La suppression de la photo: " + fullPath + " ne s'est pas complété correctement car le fichier n'existe pas.", null, null, "post"));
                                }

                                //listeActivitesPhotos.Remove(listeActivitesPhotos[y]);
                                db.Entry(listeActivitesPhotos[y]).State = EntityState.Deleted;

                                deletePhotos[i].RemoveAt(y);
                                fichiersPhotos[i].RemoveAt(y);
                                y--;
                            }
                        }
                        else if (listeActivitesPhotos[y].noPhotoActivite == 0)
                        {
                            db.Entry(listeActivitesPhotos[y]).State = EntityState.Added;
                        }
                        else
                        {
                            db.Entry(listeActivitesPhotos[y]).State = EntityState.Modified;
                        }
                    }

                    try
                    {
                        db.SaveChanges();
                    }
                    catch (DbUpdateException e)
                    {
                        Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "Mise à jour de la base de données au premier SaveChanges() des photos des avisActivites a échoué.", e, null, "post"));
                        TempData["rechercheActivite"] = rechercheActivite;

                        TempData["messageErreur"] = "Une erreur est survenu lors de la sauvegarde de vos photos, veuillez réessayer.";
                        TempData.Keep();

                        return(RedirectToAction("Index", "Activites", new { page = page }));
                    }

                    //Étape Gestion 3
                    for (int y = 0; y < listeActivitesPhotos.Count; y++)
                    {
                        if (fichiersPhotos[i][y] != null && !fichiersPhotos[i][y].FileName.ToString().ToLower().EndsWith(".jpg"))
                        {
                            TempData["messageErreur"] = fichiersPhotos[i][y].FileName.ToString() + " doit être de type jpg";

                            db.Entry(listeActivitesPhotos[y]).State = EntityState.Deleted;

                            deletePhotos[i].RemoveAt(y);
                            fichiersPhotos[i].RemoveAt(y);
                            y--;

                            break;
                        }
                        else if (fichiersPhotos[i][y] != null)
                        {
                            try
                            {
                                Membre membreCo = db.Membres.Where(m => m.noMembre == noMembreCo).FirstOrDefault();

                                string fname = Path.Combine(Server.MapPath("~/Upload/PhotosActivites/") + activiteModifier.noActivite + "$" + noMembreCo + "$" + string.Format("{0:00000}", listeActivitesPhotos[y].noPhotoActivite) + ".jpg");

                                fichiersPhotos[i][y].SaveAs(fname);

                                listeActivitesPhotos[y].nomFichierPhoto = activiteModifier.noActivite + "$" + noMembreCo + "$" + string.Format("{0:00000}", listeActivitesPhotos[y].noPhotoActivite) + ".jpg";
                            }
                            catch (Exception e)
                            {
                                Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "Impossible de sauvegarder le fichier: " + fichiersPhotos[i][y].FileName.ToString() + ".", e, null, "post"));
                                this.ModelState.AddModelError("nomFichierPhoto", fichiersPhotos[i][y].FileName.ToString() + " incapable de sauvgarder.");
                            }
                        }
                        else
                        {
                            if (listeActivitesPhotos[y].nomFichierPhoto.Equals("00000.jpg"))
                            {
                                TempData["messageErreur"] = "Veuillez définir une photo pour la/les nouvelle(s) photo(s)";
                            }
                        }
                    }

                    try
                    {
                        db.SaveChanges();
                    }
                    catch (DbUpdateException e)
                    {
                        Elmah.ErrorSignal.FromCurrentContext().Raise(Utilitaires.templateException("Index", "Activites", "Mise à jour de la base de données pour la deuxième fois à la suite de l'ajout de photos a échoué.", e, null, "post"));
                        TempData["rechercheActivite"] = rechercheActivite;

                        TempData["messageErreur"] = "Une erreur est survenu lors de la sauvegarde de vos photos, veuillez réessayer.";
                        TempData.Keep();

                        return(RedirectToAction("Index", "Activites", new { page = page }));
                    }
                }
            }

            TempData["rechercheActivite"] = rechercheActivite;

            return(RedirectToAction("Index", "Activites", new { page = page }));
        }