示例#1
0
        public ActionResult EditCapacityGroup(CapacityGroupEditModel model)
        {
            var currGroup = Db.CapacityGroups.SingleOrDefault(g => g.Id == model.CapacityGroup.Id);

            if (currGroup != null)
            {
                currGroup.Name = model.Name;
                currGroup.InSS = model.InSS;
                currGroup.InWS = model.InWS;

                currGroup.Aliases.Clear();
                if (!string.IsNullOrEmpty(model.AliasList))
                {
                    var elems = model.AliasList.Split(',');
                    foreach (var elem in elems)
                    {
                        var groupAlias = new GroupAlias
                        {
                            CapacityGroup = currGroup,
                            Name          = elem
                        };

                        Db.GroupAliases.Add(groupAlias);
                    }
                }

                Db.SaveChanges();
            }

            return(RedirectToAction("GroupList", new { id = currGroup.CurriculumGroup.Curriculum.Id }));
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ActionResult Details(Guid id)
        {
            var curriculum = Db.Curricula.SingleOrDefault(c => c.Id == id);

            if (curriculum.ShortName.Equals("WI"))
            {
                var g = curriculum.CurriculumGroups.SingleOrDefault(x => x.Name.Equals("2"));
                if (g != null)
                {
                    var g2 = g.CapacityGroups.SingleOrDefault(x => x.Name.Equals("C"));
                    var g3 = g2.Aliases.SingleOrDefault(x => x.Name.Equals("2C-IMT"));
                    if (g3 == null)
                    {
                        g3 = new GroupAlias
                        {
                            CapacityGroup = g2,
                            Name          = "2C-IMT"
                        };

                        Db.GroupAliases.Add(g3);
                        Db.SaveChanges();
                    }
                }
            }

            SetEditRights();

            return(View(curriculum));
        }
示例#3
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public ActionResult InsertIMT()
        {
            var wi   = Db.Curricula.SingleOrDefault(x => x.ShortName.Equals("WI"));
            var wi1  = wi.CurriculumGroups.SingleOrDefault(x => x.Name.Equals("1"));
            var wi1C = wi1.CapacityGroups.SingleOrDefault(x => x.Name.Equals("C"));

            var imt = new GroupAlias
            {
                CapacityGroup = wi1C,
                Name          = "1C-IMT"
            };

            Db.GroupAliases.Add(imt);
            wi1C.Aliases.Add(imt);

            Db.SaveChanges();


            return(RedirectToAction("Index"));
        }
示例#4
0
        public ActionResult ImportData(HttpPostedFileBase importFile)
        {
            if (importFile != null)
            {
                var bytes = new byte[importFile.ContentLength];
                importFile.InputStream.Read(bytes, 0, importFile.ContentLength);

                var stream = new System.IO.MemoryStream(bytes);
                var reader = new System.IO.StreamReader(stream, Encoding.Default);
                var text   = reader.ReadToEnd();

                string[] lines = text.Split('\n');


                var i = 0;
                foreach (var line in lines)
                {
                    if (i > 0)
                    {
                        string newline = line.Trim();

                        if (!string.IsNullOrEmpty(newline))
                        {
                            string[] words = newline.Split(';');

                            var fk    = words[0]; // Kurzname Fakultät
                            var cu    = words[1]; // Kurzname Studiengang
                            var sg    = words[2]; // Name Studiengruppe
                            var cg    = words[3]; // Name Kapazitätsgruppe - kann leer sein
                            var ws    = words[4]; // Kapazitätsgruppe wird im WS angeboten
                            var ss    = words[5]; // Kapazitätsgruppe wird im SS angeboten
                            var untis = words[6]; // Kürzel gpUntis

                            // Vorbedingung
                            // Fakultät und Studiengang müssen existieren
                            var faculty = Db.Organisers.SingleOrDefault(f => f.ShortName.Equals(fk));
                            if (faculty != null)
                            {
                                var curriculum = faculty.Curricula.SingleOrDefault(c => c.ShortName.Equals(cu));

                                if (curriculum != null)
                                {
                                    var studyGroup = curriculum.CurriculumGroups.SingleOrDefault(g => g.Name.Equals(sg));

                                    // Neue Studiengruppen werden automatisch angelegt
                                    if (studyGroup == null)
                                    {
                                        studyGroup = new CurriculumGroup
                                        {
                                            Name           = sg,
                                            Curriculum     = curriculum,
                                            IsSubscribable = false
                                        };
                                        Db.CurriculumGroups.Add(studyGroup);
                                        Db.SaveChanges();
                                    }

                                    var capacityGroup = string.IsNullOrEmpty(cg) ?
                                                        studyGroup.CapacityGroups.SingleOrDefault(g => string.IsNullOrEmpty(g.Name)) :
                                                        studyGroup.CapacityGroups.SingleOrDefault(g => g.Name.Equals(cg));

                                    // Neue Kapazitätsgruppen werden automatisch angelegt
                                    if (capacityGroup == null)
                                    {
                                        capacityGroup = new CapacityGroup
                                        {
                                            CurriculumGroup = studyGroup,
                                            Name            = cg
                                        };
                                        Db.CapacityGroups.Add(capacityGroup);
                                        Db.SaveChanges();
                                    }

                                    // ggf. bereits vorhandene Eigenschaften überschreiben
                                    capacityGroup.InWS = string.Equals(ws, "WS");
                                    capacityGroup.InSS = string.Equals(ss, "SS");
                                    Db.SaveChanges();

                                    var alias = capacityGroup.Aliases.SingleOrDefault(a => a.Name.Equals(untis));

                                    if (alias == null)
                                    {
                                        alias = new GroupAlias
                                        {
                                            CapacityGroup = capacityGroup,
                                            Name          = untis
                                        };
                                        Db.GroupAliases.Add(alias);
                                        Db.SaveChanges();
                                    }
                                }
                            }
                        }
                    }
                    i++;
                }
            }

            return(RedirectToAction("Index"));
        }
示例#5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="db"></param>
        /// <param name="gruppenId">Gruppenalias nach dem in der Datenbank gesucht wird</param>
        /// <returns></returns>
        private List <SemesterGroup> InitSemesterGroups(TimeTableDbContext db, string gruppenId)
        {
            var semester = db.Semesters.SingleOrDefault(s => s.Id == _semId);
            var org      = db.Organisers.SingleOrDefault(x => x.Id == _orgId);

            // Annahme, die Semestergruppen existieren!
            var semGroupList = new List <SemesterGroup>();

            // Annahme, die Semestergruppen existieren nicht alle und müssen ggf. angelegt werden

            // damit man nach den Alias namen in Abhängigkeit der Studiengänge / Fakultät suchen kann
            // so müssen die Namen derzeit auf globale Ebene eindeutig sein
            var aliasList = db.GroupAliases.Where(g => g.Name.ToUpper().Equals(gruppenId.ToUpper()) &&
                                                  g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == _orgId).ToList();

            // falls leer, jetzt in Zuordnungen nachsehen
            if (!aliasList.Any())
            {
                var zuordnungen = _import.GruppenZuordnungen.Where(x => x.Alias.Equals(gruppenId));

                foreach (var zuordnung in zuordnungen)
                {
                    // Studiengang finden
                    var curr = db.Curricula.SingleOrDefault(x =>
                                                            x.ShortName.Equals(zuordnung.Studiengang) &&
                                                            x.Organiser.Id == org.Id);
                    if (curr == null)
                    {
                        curr = new TimeTable.Data.Curriculum
                        {
                            Organiser = org,
                            ShortName = zuordnung.Studiengang,
                            Name      = zuordnung.Studiengang
                        };
                        db.Curricula.Add(curr);
                    }

                    var sg = curr.CurriculumGroups.SingleOrDefault(x => x.Name.Equals(zuordnung.Studiengruppe));
                    if (sg == null)
                    {
                        sg = new CurriculumGroup
                        {
                            Name           = zuordnung.Studiengruppe,
                            IsSubscribable = true,
                            Curriculum     = curr
                        };
                        db.CurriculumGroups.Add(sg);
                        curr.CurriculumGroups.Add(sg);
                    }

                    var cg = string.IsNullOrEmpty(zuordnung.Kapazitätsgruppe) ?
                             sg.CapacityGroups.SingleOrDefault(x => string.IsNullOrEmpty(x.Name)) :
                             sg.CapacityGroups.SingleOrDefault(x => x.Name.Equals(zuordnung.Kapazitätsgruppe));
                    if (cg == null)
                    {
                        cg = new CapacityGroup
                        {
                            InSS            = true,
                            InWS            = true,
                            Name            = zuordnung.Kapazitätsgruppe,
                            CurriculumGroup = sg
                        };
                        db.CapacityGroups.Add(cg);
                        sg.CapacityGroups.Add(cg);
                    }

                    var al = cg.Aliases.SingleOrDefault(x => x.Name.Equals(zuordnung.Alias));
                    if (al == null)
                    {
                        al = new GroupAlias
                        {
                            Name          = zuordnung.Alias,
                            CapacityGroup = cg
                        };
                        db.GroupAliases.Add(al);
                        cg.Aliases.Add(al);
                    }

                    aliasList.Add(al);
                }
                db.SaveChanges();
            }


            foreach (var groupAlias in aliasList)
            {
                // zugehörige Kapazitätsgruppe
                var capGroup = groupAlias.CapacityGroup;

                // im semester suchen
                var semGroup = semester.Groups.SingleOrDefault(g => g.CapacityGroup.Id == capGroup.Id);

                if (semGroup == null)
                {
                    // semestergruppe gibt es nicht => auf jeden Fall anlegen
                    semGroup = new SemesterGroup
                    {
                        CapacityGroup = capGroup,
                        Semester      = semester,
                    };

                    _Logger.InfoFormat("Semestergruppe {0} angelegt {1}", semGroup.FullName, gruppenId);

                    capGroup.SemesterGroups.Add(semGroup);
                    db.SemesterGroups.Add(semGroup);
                    db.SaveChanges();
                }

                semGroupList.Add(semGroup);
            }

            return(semGroupList);
        }