public ActionResult CreateCieGroups() { var semester = Db.Semesters.SingleOrDefault(x => x.Name.Equals("WiSe 2018")); // Alle Curricula durchgehen foreach (var curriculum in Db.Curricula.Where(x => x.ShortName.Equals("CIE-B") || x.ShortName.Equals("CIE-M")).ToList()) { foreach (var curriculumGroup in curriculum.CurriculumGroups.ToList()) { foreach (var capacityGroup in curriculumGroup.CapacityGroups.ToList()) { var exist = semester.Groups.Any(g => g.CapacityGroup.Id == capacityGroup.Id); if (!exist) { var semGroup = new SemesterGroup { CapacityGroup = capacityGroup, CurriculumGroup = capacityGroup.CurriculumGroup, // nur noch aus Gründen der Sicherheit Semester = semester }; semester.Groups.Add(semGroup); Db.SemesterGroups.Add(semGroup); } } } } Db.SaveChanges(); return(RedirectToAction("Index", "Dashboard")); }
/// <summary> /// /// </summary> public ActionResult ChangeGroups() { var sem = SemesterService.GetSemester(DateTime.Today); var org = Db.Organisers.SingleOrDefault(x => x.ShortName.Equals("FK 11")); var curr = org.Curricula.SingleOrDefault(x => x.ShortName.Equals("BASA Präsenz")); for (var i = 1; i <= 7; i++) { var sGroupVZ = $"{i} VZ"; var currGroupVZ = curr.CurriculumGroups.SingleOrDefault(x => x.Name.Equals(sGroupVZ)); var semGroup = Db.SemesterGroups.SingleOrDefault(x => x.Semester.Id == sem.Id && x.CapacityGroup.CurriculumGroup.Id == currGroupVZ.Id); if (semGroup == null) { semGroup = new SemesterGroup { Semester = sem, CapacityGroup = currGroupVZ.CapacityGroups.FirstOrDefault() }; Db.SemesterGroups.Add(semGroup); } currGroupVZ.Name = $"{i}"; } Db.SaveChanges(); return(RedirectToAction("Index", "Dashboard")); }
/// <summary> /// /// </summary> /// <param name="currName"></param> /// <param name="semName"></param> /// <param name="srcCurrGroupName"></param> /// <param name="srcSemGroupName"></param> public void DeleteGroup(string currName, string semName, string srcCurrGroupName, string srcSemGroupName) { // Die Semestergruppe, um die es geht SemesterGroup srcSemGroup = null; // Die Semestergruppe hat keinen Eigennamen, d.h. es muss nach "leer" gesucht werden if (string.IsNullOrEmpty(srcSemGroupName)) { srcSemGroup = Db.SemesterGroups.SingleOrDefault(s => s.Semester.Name.Equals(semName) && s.CurriculumGroup.Curriculum.ShortName.Equals( currName) && s.CurriculumGroup.Name.Equals(srcCurrGroupName) && string.IsNullOrEmpty(s.Name)); } else { srcSemGroup = Db.SemesterGroups.SingleOrDefault(s => s.Semester.Name.Equals(semName) && s.CurriculumGroup.Curriculum.ShortName.Equals( currName) && s.CurriculumGroup.Name.Equals(srcCurrGroupName) && !string.IsNullOrEmpty(s.Name) && s.Name.Equals(srcSemGroupName)); } DeleteGroup(srcSemGroup); }
private void MergeGroup(SemesterGroup srcSemGroup, SemesterGroup trgSemGroup) { if (srcSemGroup != null && trgSemGroup != null) { foreach (var activity in srcSemGroup.Activities.ToList()) { srcSemGroup.Activities.Remove(activity); trgSemGroup.Activities.Add(activity); } foreach (var subscription in srcSemGroup.Subscriptions.ToList()) { srcSemGroup.Subscriptions.Remove(subscription); trgSemGroup.Subscriptions.Add(subscription); } foreach (var occurrenceGroup in srcSemGroup.OccurrenceGroups.ToList()) { srcSemGroup.OccurrenceGroups.Remove(occurrenceGroup); trgSemGroup.OccurrenceGroups.Add(occurrenceGroup); } Db.SaveChanges(); } }
private void DeleteGroup(SemesterGroup semGroup) { if (semGroup != null && !semGroup.Subscriptions.Any() && !semGroup.Activities.Any()) { Db.SemesterGroups.Remove(semGroup); Db.SaveChanges(); } }
private void MoveGroup(SemesterGroup semGroup, CapacityGroup capGroup) { // beide Gruppen müssen existieren if (semGroup != null && capGroup != null && semGroup.CapacityGroup != capGroup) { if (semGroup.CapacityGroup != null) { // aus der bisherigen CapGroup die Semestergruppe entfernen semGroup.CapacityGroup.SemesterGroups.Remove(semGroup); } semGroup.CapacityGroup = capGroup; capGroup.SemesterGroups.Add(semGroup); Db.SaveChanges(); } }
/// <summary> /// /// </summary> /// <param name="group"></param> /// <returns></returns> public List <string> GetStudents(SemesterGroup group) { var courses = Db.Activities.OfType <Course>().Where(x => x.SemesterGroups.Any(g => g.Id == group.Id)).ToList(); var allSubscriptions = new List <OccurrenceSubscription>(); foreach (var course in courses) { allSubscriptions.AddRange(course.Occurrence.Subscriptions); } var allStudents = allSubscriptions.Select(s => s.UserId).Distinct().ToList(); return(allStudents); }
/// <summary> /// /// </summary> /// <param name="id"></param> /// <returns></returns> public ActionResult InitGroups(Guid id) { var semester = SemesterService.GetSemester(id); var org = GetMyOrganisation(); if (semester == null) { return(RedirectToAction("Index")); } // Alle Curricula durchgehen foreach (var curriculum in Db.Curricula.Where(x => x.Organiser.Id == org.Id).ToList()) { foreach (var curriculumGroup in curriculum.CurriculumGroups.ToList()) { foreach (var capacityGroup in curriculumGroup.CapacityGroups.ToList()) { var exist = semester.Groups.Any(g => g.CapacityGroup.Id == capacityGroup.Id); if (!exist) { var semGroup = new SemesterGroup { CapacityGroup = capacityGroup, CurriculumGroup = capacityGroup.CurriculumGroup, // nur noch aus Gründen der Sicherheit Semester = semester }; semester.Groups.Add(semGroup); Db.SemesterGroups.Add(semGroup); } } } } Db.SaveChanges(); return(RedirectToAction("AdminGroups", new { id = id })); }
/// <summary> /// /// </summary> /// <returns></returns> public ActionResult InitWISemesterGroups() { var semester = Db.Semesters.FirstOrDefault(); var isWS = semester.Name.StartsWith("WS"); var currs = Db.Curricula.ToList(); foreach (var curriculum in currs) { foreach (var curriculumGroup in curriculum.CurriculumGroups.ToList()) { foreach (var capacityGroup in curriculumGroup.CapacityGroups.ToList()) { if ((capacityGroup.InWS && isWS) || (capacityGroup.InSS && !isWS)) { var exist = semester.Groups.Any(g => g.CapacityGroup.Id == capacityGroup.Id); if (!exist) { var semGroup = new SemesterGroup { CapacityGroup = capacityGroup, Semester = semester }; semester.Groups.Add(semGroup); Db.SemesterGroups.Add(semGroup); } } } } } Db.SaveChanges(); return(RedirectToAction("Index")); }
/// <summary> /// /// </summary> /// <param name="currName">Name des Studiengangs: WI, MBA</param> /// <param name="semName">Name des Semesters: WS15</param> /// <param name="srcCurrGroupName">Name der Studiengruppe (Ausgangslage)</param> /// <param name="srcSemGroupName">Name in der Semestergruppe (veraltet)</param> /// <param name="trgCurrGroupName">Name der Studiengruppe (Ziel) - i.d.R. identisch zu Ausgangslage</param> /// <param name="trgCapGroupName">Name der Kapazitätsgruppe</param> public void MoveGroup(string currName, string semName, string srcCurrGroupName, string srcSemGroupName, string trgCurrGroupName, string trgCapGroupName) { // Die Semestergruppe, um die es geht SemesterGroup semGroup = null; // Die Semestergruppe hat keinen Eigennamen, d.h. es muss nach "leer" gesucht werden if (string.IsNullOrEmpty(srcSemGroupName)) { semGroup = Db.SemesterGroups.SingleOrDefault(s => s.Semester.Name.Equals(semName) && s.CurriculumGroup.Curriculum.ShortName.Equals(currName) && s.CurriculumGroup.Name.Equals(srcCurrGroupName) && string.IsNullOrEmpty(s.Name)); } else { semGroup = Db.SemesterGroups.SingleOrDefault(s => s.Semester.Name.Equals(semName) && s.CurriculumGroup.Curriculum.ShortName.Equals(currName) && s.CurriculumGroup.Name.Equals(srcCurrGroupName) && !string.IsNullOrEmpty(s.Name) && s.Name.Equals(srcSemGroupName)); } // Die Kapazitätsgruppe, die verbunden werden soll CapacityGroup capGroup = null; if (string.IsNullOrEmpty(trgCapGroupName)) { capGroup = Db.CapacityGroups.SingleOrDefault(g => g.CurriculumGroup.Curriculum.ShortName.Equals(currName) && g.CurriculumGroup.Name.Equals(trgCurrGroupName) && string.IsNullOrEmpty(g.Name)); } else { capGroup = Db.CapacityGroups.SingleOrDefault(g => g.CurriculumGroup.Curriculum.ShortName.Equals(currName) && g.CurriculumGroup.Name.Equals(trgCurrGroupName) && !string.IsNullOrEmpty(g.Name) && g.Name.Equals(trgCapGroupName)); } MoveGroup(semGroup, capGroup); }
/// <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>(); // suche alle aktuellen Zuordnungen zu dieser gruppenID 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); } // bis hierher habe ich ohne Semesterbezug gearbeitet // jetzt noch die Semestergruppe var semGroup = cg.SemesterGroups.SingleOrDefault(x => x.Semester.Id == semester.Id); if (semGroup == null) { // semestergruppe gibt es nicht => auf jeden Fall anlegen semGroup = new SemesterGroup { CapacityGroup = cg, Semester = semester, }; _Logger.InfoFormat("Semestergruppe {0} angelegt {1}", semGroup.FullName, gruppenId); cg.SemesterGroups.Add(semGroup); db.SemesterGroups.Add(semGroup); } semGroupList.Add(semGroup); } db.SaveChanges(); return(semGroupList); }
private TimeTable.Data.Curriculum GetCurriculum(TimeTableDbContext db, Semester semester, string orgName, string currName) { var org = db.Organisers.SingleOrDefault(x => x.ShortName.Equals(orgName)); var curr = org.Curricula.SingleOrDefault(x => x.ShortName.Equals(currName)); if (curr == null) { curr = new TimeTable.Data.Curriculum { ShortName = currName, Name = currName, Organiser = org }; db.Curricula.Add(curr); db.SaveChanges(); } // Gleich alles notwendige anlegen var wpmCurrciculumGroup = curr.CurriculumGroups.SingleOrDefault(x => x.Name.Equals("WPM")); if (wpmCurrciculumGroup == null) { wpmCurrciculumGroup = new CurriculumGroup { Curriculum = curr, Name = "WPM", IsSubscribable = true, }; db.CurriculumGroups.Add(wpmCurrciculumGroup); db.SaveChanges(); } var wpmCapacityGroup = wpmCurrciculumGroup.CapacityGroups.FirstOrDefault(); if (wpmCapacityGroup == null) { wpmCapacityGroup = new CapacityGroup { CurriculumGroup = wpmCurrciculumGroup, Name = string.Empty, InSS = true, InWS = true }; db.CapacityGroups.Add(wpmCapacityGroup); db.SaveChanges(); } var wpmSemesterGroup = db.SemesterGroups.FirstOrDefault(x => x.CapacityGroup.Id == wpmCapacityGroup.Id && x.Semester.Id == semester.Id); if (wpmSemesterGroup == null) { wpmSemesterGroup = new SemesterGroup { Semester = semester, CapacityGroup = wpmCapacityGroup, IsAvailable = false // zu Beginn nicht freigegeben }; db.SemesterGroups.Add(wpmSemesterGroup); db.SaveChanges(); } return(curr); }
public ActionResult CreateThesis(CourseCreateModelExtended model) { var org = GetMyOrganisation(); var semester = SemesterService.GetSemester(model.SemesterId); var course = new Exam { Name = model.Name, ShortName = model.ShortName, Organiser = org, Occurrence = new Occurrence { Capacity = -1, IsAvailable = true, FromIsRestricted = false, UntilIsRestricted = false, IsCanceled = false, IsMoved = false, UseGroups = false, }, }; // da kommen Kapazitätsgruppen // d.h. Semestergruppe suchen und ggf. anlegen if (model.GroupIds != null) { foreach (var groupId in model.GroupIds) { var capGroup = Db.CapacityGroups.SingleOrDefault(g => g.Id == groupId); var semGroup = Db.SemesterGroups.SingleOrDefault( g => g.Semester.Id == semester.Id && g.CapacityGroup.Id == groupId); // die Semestergruppe gibt es nicht => anlegen if (semGroup == null) { semGroup = new SemesterGroup { CapacityGroup = capGroup, Semester = semester, IsAvailable = false, }; Db.SemesterGroups.Add(semGroup); } course.SemesterGroups.Add(semGroup); var occGroup = new OccurrenceGroup { Capacity = 0, FitToCurriculumOnly = true, Occurrence = course.Occurrence }; occGroup.SemesterGroups.Add(semGroup); semGroup.OccurrenceGroups.Add(occGroup); course.Occurrence.Groups.Add(occGroup); Db.OccurrenceGroups.Add(occGroup); } } var member = GetMyMembership(); if (member != null) { // das Objeklt muss aus dem gleichen Kontext kommen var me = Db.Members.SingleOrDefault(m => m.Id == member.Id); ActivityOwner owner = new ActivityOwner { Activity = course, Member = me, IsLocked = false }; course.Owners.Add(owner); Db.ActivityOwners.Add(owner); } Db.Activities.Add(course); Db.SaveChanges(); return(PartialView("_CreateThesisSuccess", course)); }
public List <Course> GetCourses(ApplicationUser user, SemesterGroup group) { return(Db.Activities.OfType <Course>().Where(x => x.SemesterGroups.Any(g => g.Id == group.Id) && x.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id))).ToList()); }
/// <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); }
public string ImportCourse(ScheduleCourse scheduleCourse) { string msg; _Logger.DebugFormat("Importiere Fach: {0}", scheduleCourse.Name); _report.AppendFormat("<h1>Erzeuge LV \"{0} ({1})\" - [{2}]</h1>", scheduleCourse.Name, scheduleCourse.ShortName, scheduleCourse.CourseId); _report.AppendLine(); var db = new TimeTableDbContext(); var organiser = db.Organisers.SingleOrDefault(s => s.Id == _orgId); var sem = db.Semesters.SingleOrDefault(s => s.Id == _semId); long msStart = sw.ElapsedMilliseconds; var course = new Course { ExternalSource = "JSON", ExternalId = scheduleCourse.CourseId, Organiser = organiser, ShortName = scheduleCourse.ShortName, Name = scheduleCourse.Name, Description = scheduleCourse.Description, Occurrence = CreateDefaultOccurrence(scheduleCourse.SeatRestriction ?? 0), IsInternal = true, }; // Kurs sofort speichern, damit die ID gesichert ist db.Activities.Add(course); db.SaveChanges(); long msEnd = sw.ElapsedMilliseconds; _Logger.DebugFormat("Dauer: {0}ms", msEnd - msStart); msStart = msEnd; _report.AppendLine("<h2>Bezeichnungen</h2>"); _report.AppendLine("<table>"); _report.AppendFormat("<tr><td>Name</td><td>{0}</td></tr>", course.Name); _report.AppendFormat("<tr><td>Kurzname</td><td>{0}</td></tr>", course.ShortName); _report.AppendFormat("<tr><td>Beschreibung</td><td>{0}</td></tr>", course.Description); _report.AppendLine("</table>"); // jetzt die Gruppen foreach (var scheduleGroup in scheduleCourse.Groups) { // Fakultät ermitteln var org = db.Organisers.SingleOrDefault(x => x.ShortName.Equals(scheduleGroup.FacultyName)); // Studiengang innerhalb der Fakultät ermitteln var curr = org.Curricula.SingleOrDefault(x => x.ShortName.Equals(scheduleGroup.CurriculumShortName)); if (curr == null) { curr = new TimeTable.Data.Curriculum { ShortName = scheduleGroup.CurriculumShortName, Name = scheduleGroup.CurriculumName, Organiser = org }; db.Curricula.Add(curr); db.SaveChanges(); } // Studiengruppe innerhalb des Studiengangs ermitteln var groupName = scheduleGroup.GroupName; // Sonderlocke FK 11 // aus der LV-Nummer das Semester raussuchen /* OHI 20180720: wieder ausgebaut, weil Schnittstelle jetzt sauber befüllt ist * if (org.ShortName.Equals("FK 11")) * { * if (!string.IsNullOrEmpty(course.ShortName)) * { * groupName = course.ShortName[1].ToString(); * * } * else * { * groupName = "#N.V."; * } * } */ var currGroup = curr.CurriculumGroups.SingleOrDefault(x => x.Name.Equals(groupName)); if (currGroup == null) { currGroup = new CurriculumGroup { Curriculum = curr, Name = groupName, IsSubscribable = true, }; db.CurriculumGroups.Add(currGroup); db.SaveChanges(); } // Kapazitätsgruppe innerhalb der Studiengruppe ermitteln CapacityGroup capGroup = null; if (string.IsNullOrEmpty(scheduleGroup.SubGroupName)) { capGroup = currGroup.CapacityGroups.SingleOrDefault(x => string.IsNullOrEmpty(x.Name)); if (capGroup == null) { capGroup = new CapacityGroup { CurriculumGroup = currGroup, Name = string.Empty, InSS = scheduleGroup.SemesterName.StartsWith("SS"), InWS = scheduleGroup.SemesterName.StartsWith("WS") }; db.CapacityGroups.Add(capGroup); db.SaveChanges(); } } else { capGroup = currGroup.CapacityGroups.SingleOrDefault(x => !string.IsNullOrEmpty(x.Name) && x.Name.Equals(scheduleGroup.SubGroupName)); if (capGroup == null) { capGroup = new CapacityGroup { CurriculumGroup = currGroup, Name = scheduleGroup.SubGroupName, InSS = scheduleGroup.SemesterName.StartsWith("SS"), InWS = scheduleGroup.SemesterName.StartsWith("WS") }; db.CapacityGroups.Add(capGroup); db.SaveChanges(); } } // Semester ermitteln var semester = db.Semesters.SingleOrDefault(x => x.Name.Equals(scheduleGroup.SemesterName)); if (semester.Id == sem.Id) { // jetzt können wir die Semestergruppe ermitteln var semGroup = db.SemesterGroups.SingleOrDefault(x => x.Semester.Id == semester.Id && x.CapacityGroup.Id == capGroup.Id); if (semGroup == null) { semGroup = new SemesterGroup { Semester = semester, CapacityGroup = capGroup, IsAvailable = false // zu Beginn nicht freigegeben }; db.SemesterGroups.Add(semGroup); db.SaveChanges(); } course.SemesterGroups.Add(semGroup); semGroup.Activities.Add(course); // zu jeder Semestergruppe gibt es dann noch eine // Gruppe für Platzverlosung var occGroup = course.Occurrence.Groups.SingleOrDefault( gg => gg.SemesterGroups.Any(s => s.Id == semGroup.Id)); if (occGroup == null) { occGroup = new OccurrenceGroup { Capacity = 0, FitToCurriculumOnly = true, Occurrence = course.Occurrence }; occGroup.SemesterGroups.Add(semGroup); semGroup.OccurrenceGroups.Add(occGroup); course.Occurrence.Groups.Add(occGroup); db.OccurrenceGroups.Add(occGroup); } // NEU: Chapter und Topics if (!string.IsNullOrEmpty(scheduleGroup.ChapterName) && !string.IsNullOrEmpty(scheduleGroup.TopicName)) { var chapter = curr.Chapters.FirstOrDefault(x => x.Name.Equals(scheduleGroup.ChapterName)); if (chapter == null) { chapter = new CurriculumChapter { Curriculum = curr, Name = scheduleGroup.ChapterName }; db.CurriculumChapters.Add(chapter); } var topic = chapter.Topics.FirstOrDefault(x => x.Name.Equals(scheduleGroup.TopicName)); if (topic == null) { topic = new CurriculumTopic { Chapter = chapter, Name = scheduleGroup.TopicName }; db.CurriculumTopics.Add(topic); } var semTopic = db.SemesterTopics.FirstOrDefault(x => x.Semester.Id == sem.Id && x.Topic.Id == topic.Id); if (semTopic == null) { semTopic = new SemesterTopic { Semester = sem, Topic = topic, }; db.SemesterTopics.Add(semTopic); } semTopic.Activities.Add(course); } } // else => Semestergruppe wird nicht angelegt } db.SaveChanges(); if (!course.SemesterGroups.Any()) { _Logger.ErrorFormat("Kurs {0} ohne Gruppe", scheduleCourse.CourseId); } // zum Schluss die Termine _report.AppendLine("<h2>Neue Termine</h2>"); _report.AppendLine("<table>"); foreach (var scheduleDate in scheduleCourse.Dates) { // Der Tag var occDate = scheduleDate.Begin.Date; bool isVorlesung = true; foreach (var sd in _semester.Dates) { // Wenn der Termin in eine vorlesungsfreie Zeit fällt, dann nicht importieren if (sd.From.Date <= occDate.Date && occDate.Date <= sd.To.Date && sd.HasCourses == false) { isVorlesung = false; } } if (isVorlesung) { var occ = new ActivityDate { Begin = scheduleDate.Begin, End = scheduleDate.End, Activity = course, Occurrence = CreateDefaultOccurrence(), }; _report.AppendLine("<tr>"); _report.AppendFormat("<td>{0}</td><td>{1}</td><td>{2}</td>", occ.Begin.ToShortDateString(), occ.Begin.ToShortTimeString(), occ.End.ToShortTimeString()); _report.AppendFormat("<td>"); foreach (var scheduleDateRoom in scheduleDate.Rooms) { _report.AppendFormat("<p>{0}", scheduleDateRoom.RoomNumber); if (!string.IsNullOrEmpty(scheduleDateRoom.RoomNumber)) { var room = db.Rooms.SingleOrDefault(r => r.Number.Equals(scheduleDateRoom.RoomNumber)); if (room == null) { room = new Room { Number = scheduleDateRoom.RoomNumber, Capacity = 0, Description = string.Empty, Owner = string.Empty, }; db.Rooms.Add(room); db.SaveChanges(); _numRooms++; _report.AppendFormat(" !!!NEUER RAUM!!!"); } var assignment = db.RoomAssignments.SingleOrDefault(x => x.Room.Id == room.Id && x.Organiser.Id == organiser.Id); if (assignment == null) { assignment = new RoomAssignment { Organiser = organiser, InternalNeedConfirmation = false, // offen für interne ExternalNeedConfirmation = true // geschlossen für externe }; room.Assignments.Add(assignment); db.RoomAssignments.Add(assignment); db.SaveChanges(); } occ.Rooms.Add(room); _report.AppendFormat("</p>"); } } _report.AppendFormat("</td>"); _report.AppendFormat("<td>"); foreach (var scheduleDateLecturer in scheduleDate.Lecturers) { _report.AppendFormat("<p>{0} ({1})", scheduleDateLecturer.Name, scheduleDateLecturer.ShortName); var lecturer = organiser.Members.SingleOrDefault(l => l.ShortName.Equals(scheduleDateLecturer.ShortName)); if (lecturer == null) { lecturer = new OrganiserMember { ShortName = scheduleDateLecturer.ShortName, Name = scheduleDateLecturer.Name, Role = String.Empty, Description = String.Empty }; organiser.Members.Add(lecturer); db.Members.Add(lecturer); db.SaveChanges(); _numLecturers++; _report.AppendFormat(" !!!NEUER DOZENT!!!"); } occ.Hosts.Add(lecturer); _report.AppendFormat("</p>"); } _report.AppendFormat("</td>"); db.ActivityDates.Add(occ); _report.AppendLine(); _report.AppendLine("</tr>"); } } _report.AppendLine("</table>"); db.SaveChanges(); msEnd = sw.ElapsedMilliseconds; _Logger.DebugFormat("Dauer {0}ms", msEnd - msStart); msg = $"Kurs {course.ShortName} mit Terminen importiert"; return(msg); }