// Ermöglicht es, einen bestimmten Gruppeneintrag zu löschen (Import: gruppenEintragID, Export: gruppenEintrageModel)
        // redirect auf error view, fallls keine authorizierung vorliegt.
        // GET: GruppenEintraege/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var userId = User.Identity.GetUserId();
            int idauth = (int)id;

            if (AuthCheck.VerantGr(idauth, userId) || AuthCheck.AutorGE(idauth, userId) || User.IsInRole("Admin"))
            {
                GruppenEintraege gruppenEintraege = db.GruppenEintraeges.Find(id);
                if (gruppenEintraege == null)
                {
                    return(HttpNotFound());
                }
                return(View(gruppenEintraege));
            }

            return(RedirectToAction("Unauthorized", "Error"));
        }
        // Liefert eine Liste von Gruppeneinträgen. Diese List enthält nur die Einträge einer bestimmten Gruppe, falls
        // eine GruppenID übergeben wird, ansonsten werden die Einträge aller Gruppen zurückgegeben
        // (Import optional: GruppenID, Export: GruppenEinträge List)
        // GET: GruppenEintraege
        public ActionResult Index(int?gruppenid)
        {
            List <GruppenEintraege> entries   = new List <GruppenEintraege>();
            List <Person>           zuordnung = new List <Person>();
            String  userid = "";
            Boolean ok     = false;                        // für prüfung auf mitgliedschaft

            Boolean[] verantwortlich = new Boolean[10000]; // Index gruppenid, Eintrag false -> Gruppe gruppenid kein Verantwortlicher
            Boolean[] autor          = new Boolean[10000]; // Index gruppenid, Eintrag false -> Gruppe gruppenid kein autor
            var       userId         = User.Identity.GetUserId();

            foreach (Gruppe gruppe in db.Gruppes)
            {
                // Wenn die Gruppe privat ist, dann prüfe, ob User Mitglied der Gruppe ist
                // falls ja oder gruppe nicht privat, dann OK und weiter (Admin sieht alles immer)
                if (gruppe.gruppenid == gruppenid && gruppe.privat == true && !User.IsInRole("Admin"))
                {
                    // hier werden PRIVATEN alle Gruppen ausgeschlossen, in denen der User nicht Mitglied ist
                    ok = false;


                    foreach (MitgliederGruppe mg in db.MitgliederGruppes)
                    {
                        if (mg.gruppenid == gruppe.gruppenid && mg.userid == userId)
                        {
                            ok = true;
                        }
                    }
                }
                else
                {
                    ok = true;
                }
            }

            if (ok)
            {
                if (gruppenid == null)
                {
                    return(View(db.GruppenEintraeges.ToList()));
                }
                else
                {
                    foreach (GruppenEintraege ge in db.GruppenEintraeges)
                    {
                        // Signal an Frontend, ob User auch autor ist und bearbeiten/löschen darf
                        autor[ge.id] = AuthCheck.AutorGE(ge.id, userId);
                        // Signal an Frontend, ob User auch Verantwortlicher ist und somit bearbeiten/löschen darf
                        verantwortlich[ge.gruppenid] = AuthCheck.VerantGr(ge.gruppenid, userId);


                        if (ge.gruppenid == gruppenid)
                        {
                            foreach (Person person in db.Person)
                            {
                                if (person.id == ge.autor)
                                {
                                    ge.autor = HelpFunctions.GetDisplayName(person.id);

                                    userid = person.id;
                                }
                            }

                            // zuordnungstabelle für verlinkung erstellen
                            Person el = new Person();
                            el.id   = userid;
                            el.name = ge.autor;

                            zuordnung.Add(el);

                            entries.Add(ge);
                        }
                    }

                    ViewBag.zuordnung      = zuordnung;
                    ViewBag.autor          = autor;
                    ViewBag.verantwortlich = verantwortlich;

                    // Bezeichnung der Gruppe in View übergeben
                    foreach (Gruppe gr in db.Gruppes)
                    {
                        if (gr.gruppenid == gruppenid)
                        {
                            ViewBag.bezeichnung = gr.bezeichnung;
                        }
                    }
                }
            }
            return(View(entries.ToList()));
        }
Beispiel #3
0
        ////////////////////////
        ///  Lehrstuhleinträge
        ////////////////////


        // Index View der Newsfeed Seite, die das NewsfeedModel verwendet
        // Import: keine
        // Export: NewsfeedModel + diverse ViewBags
        public ActionResult Index()
        {
            List <NewsFeedModel> list      = new List <NewsFeedModel>();
            List <Person>        zuordnung = new List <Person>();

            Boolean[] lverantwortlich = new Boolean[10000]; // Index lehrstuhlid, Eintrag false -> lehrstuhl lehrstuhlid kein Verantwortlicher
            Boolean[] lautor          = new Boolean[10000]; // Index lehrstuhlid, Eintrag false -> lehrstuhl lehrstuhlid kein autor
            Boolean   abonniert       = false;
            var       userId          = User.Identity.GetUserId();

            // Alle abonnierten Lehrstuhleinträge und relevanten (=mitglied) lehrstuhleinträge auslesen
            foreach (LehrstuhlEintraege le in db.LehrstuhlEintraeges)
            {
                // Signal an Frontend, ob User auch autor ist und bearbeiten/löschen darf
                lautor[le.id] = AuthCheck.AutorLE(le.id, userId);

                // Signal an Frontend, ob User auch Verantwortlicher ist und somit bearbeiten/löschen darf
                lverantwortlich[le.lehrstuhlid] = AuthCheck.VerantLehr(le.lehrstuhlid, userId);


                // prüfen, ob user mitarbeiter des lehrstuhls ist oder diesen abonniert hat
                foreach (MitarbeiterLehrstuhl ml in db.MitarbeiterLehrstuhls)
                {
                    if (ml.lehrstuhlid == le.lehrstuhlid && ml.userid == userId || User.IsInRole("Admin"))
                    {
                        abonniert = true;
                    }
                }

                foreach (AbonnentenLehrstuhl al in db.AbonnentenLehrstuhls)
                {
                    if (al.lehrstuhlid == le.lehrstuhlid && al.userid == userId || User.IsInRole("Admin"))
                    {
                        abonniert = true;
                    }
                }

                // Userid richtig darstellen
                foreach (Person person in db.Person)
                {
                    if (person.id == le.autor)
                    {
                        le.autor = HelpFunctions.GetFeedDisplayName(person.id);

                        // zuordnungstabelle für verlinkung erstellen
                        zuordnung.Add(new Person
                        {
                            id   = person.id,
                            name = le.autor
                        });
                    }
                }


                ViewBag.lautor          = lautor;
                ViewBag.lverantwortlich = lverantwortlich;

                if (abonniert)
                {
                    list.Add(new NewsFeedModel
                    {
                        id         = le.id,
                        entityid   = le.lehrstuhlid,
                        datum      = le.datum,
                        autor      = le.autor,
                        inhalt     = le.inhalt,
                        label1     = le.label1,
                        label2     = le.label2,
                        label3     = le.label3,
                        label4     = le.label4,
                        label5     = le.label5,
                        typ        = "l",
                        entityname = HelpFunctions.GetLehrstuhlName(le.lehrstuhlid)
                    });
                }

                abonniert = false;
            }

            ////////////////////////
            ///  Gruppeneinträge
            ////////////////////

            Boolean[] verantwortlich = new Boolean[10000]; // Index gruppenid, Eintrag false -> Gruppe gruppenid kein Verantwortlicher
            Boolean[] autor          = new Boolean[10000]; // Index gruppenid, Eintrag false -> Gruppe gruppenid kein autor
            Boolean   mitglied       = false;

            foreach (GruppenEintraege le in db.GruppenEintraeges)
            {
                // Signal an Frontend, ob User auch autor ist und bearbeiten/löschen darf
                autor[le.id] = AuthCheck.AutorGE(le.id, userId);

                // Signal an Frontend, ob User auch Verantwortlicher ist und somit bearbeiten/löschen darf
                verantwortlich[le.gruppenid] = AuthCheck.VerantGr(le.gruppenid, userId);

                // prüfen, ob user mitglied der gruppe ist
                foreach (MitgliederGruppe mg in db.MitgliederGruppes)
                {
                    if (mg.gruppenid == le.gruppenid && mg.userid == userId || User.IsInRole("Admin"))
                    {
                        mitglied = true;
                    }
                }


                // Userid richtig darstellen
                foreach (Person person in db.Person)
                {
                    if (person.id == le.autor)
                    {
                        le.autor = HelpFunctions.GetFeedDisplayName(person.id);

                        // zuordnungstabelle für verlinkung erstellen
                        zuordnung.Add(new Person
                        {
                            id   = person.id,
                            name = le.autor
                        });
                    }
                }


                ViewBag.autor          = autor;
                ViewBag.verantwortlich = verantwortlich;

                if (mitglied)
                {
                    list.Add(new NewsFeedModel
                    {
                        id         = le.id,
                        entityid   = le.gruppenid,
                        datum      = le.datum,
                        autor      = le.autor,
                        inhalt     = le.inhalt,
                        label1     = le.label1,
                        label2     = le.label2,
                        label3     = le.label3,
                        label4     = le.label4,
                        label5     = le.label5,
                        typ        = "g",
                        entityname = HelpFunctions.GetGruppenName(le.gruppenid)
                    });
                }
                mitglied = false;
            }



            // Gruppen und Lehrstühle müssen in eienr Partial View angezeigt werden!
            // var lehrstuehle = db.Lehrstuhls.ToList();
            ViewBag.zuordnung = zuordnung.Distinct();

            return(View(list));
        }