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);
}
