public void SendLotteryClearedMails(LotteryDrawing drawing, OrganiserMember member)
{
foreach (var game in Drawing.Games)
{
var nNeeded = game.CoursesWanted - game.Seats.Count;
// Versand nur an jene, die Plätze auf der Warteliste haben
if (nNeeded > 0)
{
var email = new LotteryDrawingStudentEmail("LotteryClearedStudent")
{
Subject = "[nine] Wahlverfahren " + Drawing.Lottery.Name,
Game = game,
User = UserService.GetUser(game.Student.UserId),
Drawing = drawing,
Member = member
};
try
{
if (email.User != null)
{
EmailService.Send(email);
Logger.InfoFormat("E-Mail an {0} erfolgreich versendet", email.User.Email);
}
}
catch (Exception exMail)
{
Logger.ErrorFormat("Fehler bei E-Mail Versand an: {0} - Ursache {1}", email.User.Email,
exMail.Message);
}
}
}
}
public void SendLotteryRemoveMail(LotteryDrawing drawing, OrganiserMember member, Lottery lottery, Course course, OccurrenceSubscription subscription)
{
var email = new LotteryDrawingStudentEmail("LotteryRemoveStudent")
{
Subject = "[nine] Wahlverfahren " + Drawing.Lottery.Name,
Game = null,
User = UserService.GetUser(subscription.UserId),
Lottery = lottery,
Drawing = drawing,
Member = member,
Course = course,
Subscription = subscription,
};
try
{
if (email.User != null)
{
EmailService.Send(email);
Logger.InfoFormat("E-Mail an {0} erfolgreich versendet", email.User.Email);
}
}
catch (Exception exMail)
{
Logger.ErrorFormat("Fehler bei E-Mail Versand an: {0} - Ursache {1}", email.User.Email,
exMail.Message);
}
}
private OrganiserMember InitLecturer(TimeTableDbContext db, Dozent dozent, ActivityOrganiser organiser)
{
var n = organiser.Members.Count(l => l.ShortName.Equals(dozent.DozentID));
if (n > 1)
{
return(null);
}
var lecturer = organiser.Members.FirstOrDefault(l => l.ShortName.Equals(dozent.DozentID));
if (lecturer == null)
{
string profileUrl = null;
if (dozent.Typ.ToUpper().Equals("PROF"))
{
profileUrl = string.Format("http://wi.hm.edu/dozenten/{0}/index.de.html", dozent.Name.ToLowerInvariant());
}
lecturer = new OrganiserMember
{
ShortName = dozent.DozentID,
Name = dozent.Name,
Role = dozent.Typ,
Description = dozent.Name,
UrlProfile = profileUrl,
};
organiser.Members.Add(lecturer);
db.Members.Add(lecturer);
db.SaveChanges();
_numLecturers++;
}
return(lecturer);
}
public void SendLotteryResetMails(LotteryDrawing drawing, OrganiserMember member)
{
// alles wird rückgesetzt => jeder bekommt eine Mail
foreach (var game in Drawing.Games)
{
var email = new LotteryDrawingStudentEmail("LotteryResetStudent")
{
Subject = "[nine] Wahlverfahren " + Drawing.Lottery.Name,
Game = game,
User = UserService.GetUser(game.Student.UserId),
Drawing = drawing,
Member = member
};
try
{
if (email.User != null)
{
EmailService.Send(email);
Logger.InfoFormat("E-Mail an {0} erfolgreich versendet", email.User.Email);
}
}
catch (Exception exMail)
{
Logger.ErrorFormat("Fehler bei E-Mail Versand an: {0} - Ursache {1}", email.User.Email,
exMail.Message);
}
}
}
public ActionResult DeleteConfirmed(Guid id)
{
OrganiserMember organiserMember = Db.Members.Find(id);
Db.Members.Remove(organiserMember);
Db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Ermittelt die aktuellste Sprechstunde
/// </summary>
/// <param name="lecturer"></param>
/// <returns></returns>
public OfficeHour GetLatestOfficeHour(OrganiserMember lecturer)
{
var officeHour =
Db.Activities.OfType <OfficeHour>().Where(x =>
x.Owners.Any(k => k.Member.Id == lecturer.Id)).OrderByDescending(x => x.Semester.StartCourses).FirstOrDefault();
return(officeHour);
}
public ActionResult Edit([Bind(Include = "Id,UserId,ShortName,Name,Role,Description,IsAdmin,UrlProfile")] OrganiserMember organiserMember)
{
if (ModelState.IsValid)
{
Db.Entry(organiserMember).State = EntityState.Modified;
Db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(organiserMember));
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult GetMember(Guid id)
{
var organiser = Db.Organisers.SingleOrDefault(org => org.Id == id);
if (organiser == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
// Benutzer als neues Mitglied eintragen
var user = AppUser;
if (user == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
// nach dem Benutzer suchen
var member = organiser.Members.FirstOrDefault(m => m.UserId.Equals(user.Id));
if (member == null)
{
member = new OrganiserMember
{
IsAdmin = false,
UserId = user.Id,
IsAssociated = true // "Gast"
};
organiser.Members.Add(member);
}
// Den Token generieren
var token = System.Web.Security.Membership.GeneratePassword(8, 2);
member.ShortName = token;
Db.SaveChanges();
/*
* // Eine E-Mail senden
* var mailModel = new OrgMemberMailModel
* {
* User = user,
* Organiser = organiser,
* Token = token,
* };
*
* new MailController().RegisterUnionEMail(mailModel).Deliver();
*/
return(RedirectToAction("Index"));
}
public void SendSupervisionRequest(ThesisStateModel model, OrganiserMember member, ApplicationUser user)
{
var email = new ThesisEmail("ThesisSupervisionRequest");
email.Subject = "Anfrage zur Betreuung einer Abschlussarbeit";
email.Thesis = model;
email.Member = member;
email.User = user;
SendThesisMail(email);
}
public OfficeHour GetOfficeHour(OrganiserMember lecturer, Semester sem)
{
// zuerst richtg
var officeHour =
Db.Activities.OfType <OfficeHour>().FirstOrDefault(x =>
x.Semester.Id == sem.Id &&
x.Owners.Any(k => k.Member.Id == lecturer.Id)
);
return(officeHour);
}
public void SendConditionRequestAccept(ThesisStateModel model, OrganiserMember member, ApplicationUser user)
{
var email = new ThesisEmail("ThesisMailTemplate");
email.Subject = "Ihr Antrag auf Anmeldung einer Abschlussarbeit";
email.Thesis = model;
email.Member = member;
email.User = user;
email.Body = "<p><strong>Antrag wurde angenommen. Die Voraussetzungen für die Abschlussarbeit sind erfüllt.</strong></p>";
SendThesisMail(email);
}
public ActionResult Create([Bind(Include = "Id,UserId,ShortName,Name,Role,Description,IsAdmin,UrlProfile")] OrganiserMember organiserMember)
{
if (ModelState.IsValid)
{
organiserMember.Id = Guid.NewGuid();
Db.Members.Add(organiserMember);
Db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(organiserMember));
}
public void SendSupervisionRequestDeny(ThesisStateModel model, OrganiserMember member, ApplicationUser user)
{
var email = new ThesisEmail("ThesisMailTemplate");
email.Subject = "Ihre Anfrage zur Betreuung einer Abschlussarbeit";
email.Thesis = model;
email.Member = member;
email.User = user;
email.Body = "<p><strong>Die Betreuung Ihrer Abschlussarbeit wurde abgelehnt.</strong></p>";
SendThesisMail(email);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Delete(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrganiserMember organiserMember = Db.Members.Find(id);
if (organiserMember == null)
{
return(HttpNotFound());
}
return(View(organiserMember));
}
public ActionResult CreateMember(MemberUserViewModel model)
{
var org = Db.Organisers.SingleOrDefault(m => m.Id == model.OrganiserId);
if (org != null)
{
var shortName = model.ShortName.Trim().ToUpper();
if (org.Members.Any(x => x.ShortName.ToUpper().Equals(shortName)))
{
ModelState.AddModelError("", "Diesen Kurznamen gibt es schon");
return(View(model));
}
var member = new OrganiserMember
{
Role = model.Role,
ShortName = model.ShortName,
Name = model.Name,
IsAssociated = model.IsAssociated,
};
if (!string.IsNullOrEmpty(model.UserName))
{
var user = UserManager.FindByName(model.UserName);
if (user != null)
{
member.UserId = user.Id;
// wenn es keine stud-orga ist, dann muss der Nutzer "Staff" werden
if (!org.IsStudent)
{
user.MemberState = MemberState.Staff;
UserManager.Update(user);
}
}
}
org.Members.Add(member);
Db.SaveChanges();
// Redirect zu den Members
return(RedirectToAction("Index", "OrganiserMembers"));
}
return(RedirectToAction("Index", "OrganiserMembers"));
}
private void DeleteMember(OrganiserMember member)
{
var allOwners = Db.ActivityOwners.Where(x => x.Member.Id == member.Id).ToList();
foreach (var owner in allOwners)
{
Db.ActivityOwners.Remove(owner);
}
var org = member.Organiser;
org.Members.Remove(member);
Db.Members.Remove(member);
Db.SaveChanges();
}
/// <summary>
///
/// </summary>
/// <param name="semester"></param>
/// <param name="lecturer"></param>
/// <returns></returns>
public List <Course> GetCourses(Semester semester, OrganiserMember lecturer)
{
var list = new List <Course>();
if (lecturer != null && semester != null)
{
list =
Db.Activities.OfType <Course>().Where(c =>
c.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
c.Dates.Any(oc => oc.Hosts.Any(l => l.Id == lecturer.Id)))
.OrderBy(c => c.Name)
.ToList();
}
return(list);
}
/// <summary>
///
/// </summary>
/// <param name="lecturer"></param>
/// <returns></returns>
public List <CourseHistoryModel> GetCourseHistory(OrganiserMember lecturer)
{
var list = new List <CourseHistoryModel>();
if (lecturer != null)
{
var courses =
Db.Activities.OfType <Course>().Where(c =>
c.Dates.Any(oc => oc.Hosts.Any(l => l.Id == lecturer.Id)))
.OrderBy(c => c.Name)
.ToList();
var dummySemester = new Semester()
{
Name = "XXX"
};
foreach (var course in courses)
{
// Annahme alle Gruppen gehören zum selben Semester!
var group = course.SemesterGroups.FirstOrDefault();
if (group != null)
{
var summary = new CourseHistoryModel
{
Course = course,
Semester = group.Semester,
};
list.Add(summary);
}
else
{
var summary = new CourseHistoryModel
{
Course = course,
Semester = dummySemester,
};
list.Add(summary);
}
}
}
return(list.OrderBy(l => l.Semester.Name).ThenBy(l => l.Course.Name).ToList());
}
public ActionResult CreateAdmin(MemberUserViewModel model)
{
var org = Db.Organisers.SingleOrDefault(m => m.Id == model.OrganiserId);
if (org != null)
{
// vorhandene suchen
var member = org.Members.SingleOrDefault(x => x.ShortName.Equals(model.ShortName));
if (member != null)
{
member.IsAdmin = true;
Db.SaveChanges();
}
else
{
member = new OrganiserMember
{
ShortName = model.ShortName,
Name = model.Name,
IsAdmin = true,
};
if (!string.IsNullOrEmpty(model.UserName))
{
var user = UserManager.FindByName(model.UserName);
if (user != null)
{
member.UserId = user.Id;
// wenn es keine stud-orga ist, dann muss der Nutzer "Staff" werden
if (!org.IsStudent)
{
user.MemberState = MemberState.Staff;
UserManager.Update(user);
}
}
}
org.Members.Add(member);
}
Db.SaveChanges();
}
return(RedirectToAction("Details", new { id = model.OrganiserId }));
}
public void SendConditionRequestDeny(ThesisStateModel model, OrganiserMember member, ApplicationUser user)
{
var email = new ThesisEmail("ThesisMailTemplate");
email.Subject = "Ihr Antrag auf Anmeldung einer Abschlussarbeit";
email.Thesis = model;
email.Member = member;
email.User = user;
var sb = new StringBuilder();
sb.Append(
"<p><strong>Antrag wurde abgelehnt. Die Voraussetzungen für die Abschlussarbeit sind NICHT erfüllt.</strong></p>");
sb.AppendFormat("<p>Begründung:</p><p>{0}</p>", model.Thesis.RequestMessage);
email.Body = sb.ToString();
SendThesisMail(email);
}
/// <summary>
///
/// </summary>
/// <param name="org"></param>
/// <param name="shortName"></param>
/// <returns></returns>
public OrganiserMember GetMemberByName(ActivityOrganiser org, string shortName)
{
var member = org.Members.SingleOrDefault(m => m.ShortName.Equals(shortName));
if (member == null)
{
member = new OrganiserMember
{
ShortName = shortName,
Name = shortName,
};
Db.Members.Add(member);
org.Members.Add(member);
Db.SaveChanges();
}
return(member);
}
public string GetStateMessage(OrganiserMember member)
{
var nSupervisors = Thesis.Supervisors.Count;
var didIAccepted = Thesis.Supervisors.Any(x => x.Member.Id == member.Id && x.AcceptanceDate.HasValue);
if (nSupervisors == 1)
{
if (didIAccepted)
{
return("Arbeit angenommen");
}
return("Betreuungsanfrage");
}
var nAccepted = Thesis.Supervisors.Count(x => x.AcceptanceDate.HasValue);
if (nAccepted == 0)
{
return($"Betreuungsanfrage bei {nSupervisors} Lehrenden.");
}
if (didIAccepted)
{
if (nAccepted == 1)
{
return
($"Arbeit wurde von mir angenommen. Von {nSupervisors - 1} Lehrenden steht die Antwort noch aus.");
}
return($"Arbeit wurde von mir und {nAccepted - 1} Lehrenden angenommen.");
}
if (nAccepted > 0)
{
return($"Arbeit wurde bereits von {nAccepted} Lehrenden angenommen.");
}
return("Betreuungsanfrage");
}
/// <summary>
///
/// </summary>
/// <param name="semesterName"></param>
/// <param name="lecturer"></param>
/// <returns></returns>
public List <CourseSummaryModel> GetCourses(string semesterName, OrganiserMember lecturer)
{
var list = new List <CourseSummaryModel>();
var semester = Db.Semesters.SingleOrDefault(l => l.Name.ToUpper().Equals(semesterName.ToUpper()));
if (lecturer != null && semester != null)
{
var courses =
Db.Activities.OfType <Course>().Where(c =>
c.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
c.Dates.Any(oc => oc.Hosts.Any(l => l.Id == lecturer.Id)))
.OrderBy(c => c.Name)
.ToList();
foreach (var course in courses)
{
var summary = GetCourseSummary(course);
list.Add(summary);
}
}
return(list);
}
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);
}
internal bool IsActive(OrganiserMember member, Semester semester)
{
return(Db.ActivityDates.Any(d => d.Hosts.Any(h => h.Id == member.Id) &&
d.Activity.SemesterGroups.Any(s => s.Semester.Id == semester.Id)));
}
public string ImportCourse(CieCourse scheduleCourse)
{
string msg;
_Logger.DebugFormat("Importiere Fach: {0}", scheduleCourse.name);
_report.AppendFormat("<h1>Erzeuge LV \"{0}\" - [{1}]</h1>", scheduleCourse.name,
scheduleCourse.id);
_report.AppendLine();
var db = new TimeTableDbContext();
var organiser = db.Organisers.SingleOrDefault(s => s.ShortName.Equals(scheduleCourse.department));
var sem = db.Semesters.SingleOrDefault(s => s.Id == _semId);
var cieSemGroup = db.SemesterGroups.SingleOrDefault(x =>
x.Semester.Id == sem.Id &&
x.CapacityGroup.CurriculumGroup.Curriculum.ShortName.Equals("CIE") &&
x.CapacityGroup.CurriculumGroup.Curriculum.ShortName.Equals("CIE") &&
x.CapacityGroup.CurriculumGroup.Name.Equals("CIE"));
long msStart = sw.ElapsedMilliseconds;
// suche den Kurs im bisherigen Angebot auf Grundlage des Namens
var course = GetCourse(db, sem, organiser, scheduleCourse);
if (course == null)
{
course = new Course
{
ExternalSource = "CIE",
ExternalId = scheduleCourse.id,
Organiser = organiser,
ShortName = "",
Name = scheduleCourse.name,
Description = scheduleCourse.description,
Occurrence = CreateDefaultOccurrence(scheduleCourse.availableSlots),
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
// Studiengänge ermitteln
// Den Kurs gibt es nur einmal
// Zuordnungen pro Studiengang
// Modul => d.h. duplizieren von ECTS, SWS
var curricula = GetCurricula(db, sem, scheduleCourse.department, scheduleCourse.level);
// Semestergruppe => auch hier eine "intelligente" Zuordnung
// nur machen, wenn Kurs keine Gruppen hat
if (!course.SemesterGroups.Any())
{
foreach (var curriculum in curricula)
{
// Annahme: ein CIE sind immer WPM
var wpmCurrciculumGroup = curriculum.CurriculumGroups.SingleOrDefault(x => x.Name.Equals("WPM"));
var wpmCapacityGroup = wpmCurrciculumGroup.CapacityGroups.FirstOrDefault();
var wpmSemesterGroup = db.SemesterGroups.FirstOrDefault(x =>
x.CapacityGroup.Id == wpmCapacityGroup.Id && x.Semester.Id == sem.Id);
course.SemesterGroups.Add(wpmSemesterGroup);
// 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 == wpmSemesterGroup.Id));
if (occGroup == null)
{
occGroup = new OccurrenceGroup
{
Capacity = 0,
FitToCurriculumOnly = true,
Occurrence = course.Occurrence
};
occGroup.SemesterGroups.Add(wpmSemesterGroup);
wpmSemesterGroup.OccurrenceGroups.Add(occGroup);
course.Occurrence.Groups.Add(occGroup);
db.OccurrenceGroups.Add(occGroup);
}
}
}
// Die Semestergruppe FK 13 / CIE / CIE muss immer dran
if (!course.SemesterGroups.Contains(cieSemGroup))
{
course.SemesterGroups.Add(cieSemGroup);
}
db.SaveChanges();
if (!course.SemesterGroups.Any())
{
_Logger.ErrorFormat("Kurs {0} ohne Gruppe", scheduleCourse.id);
}
// jetzt die Module
// wieder pro Studiengang
/*
* foreach (var curriculum in curricula)
* {
* //var module = GetModule(db, curriculum, scheduleCourse);
*
* var nexus = new CourseModuleNexus();
* //nexus.Requirement = module;
* nexus.Course = course;
* // nexus.ModuleCourse = // fehlt noch
*
* course.Nexus.Add(nexus);
*
* db.CourseNexus.Add(nexus);
* }
*/
db.SaveChanges();
// Das Ampelsystem
if (scheduleCourse.courseStatus.Equals("RED"))
{
course.Occurrence.IsCoterie = true;
course.Occurrence.HasHomeBias = true; // Bedeutungslos
}
else if (scheduleCourse.courseStatus.Equals("YELLOW"))
{
course.Occurrence.IsCoterie = false;
course.Occurrence.HasHomeBias = true;
}
else //(scheduleCourse.courseStatus.Equals("GREEN"))
{
course.Occurrence.IsCoterie = false;
course.Occurrence.HasHomeBias = false;
}
db.SaveChanges();
// zum Schluss die Termine
// Dummy Termin mit Dozent
_report.AppendLine("<h2>Neue Termine</h2>");
_report.AppendLine("<table>");
// Der Dummy Termin ist Vorlesungsbeginn 08:00-10:00
var occDate = sem.StartCourses.Date;
var occ = new ActivityDate
{
Begin = occDate.AddHours(8),
End = occDate.AddHours(10),
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());
// Kein Raum
_report.AppendFormat("<td>");
_report.AppendFormat("</td>");
// Dozent => der angegebene
var lec = scheduleCourse.lecturer.Split(',');
_report.AppendFormat("<td>");
foreach (var s in lec)
{
var scheduleDateLecturer = s.Trim();
_report.AppendFormat("<p>{0} ({1})", scheduleDateLecturer, scheduleDateLecturer);
var lecturer = organiser.Members.SingleOrDefault(l => l.ShortName.Equals(scheduleDateLecturer) || l.Name.Equals(scheduleDateLecturer));
if (lecturer == null)
{
lecturer = new OrganiserMember
{
ShortName = scheduleDateLecturer,
Name = scheduleDateLecturer,
Role = String.Empty,
Description = String.Empty
};
organiser.Members.Add(lecturer);
db.Members.Add(lecturer);
db.SaveChanges();
_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);
}
public string ImportReservation(ScheduleCourse scheduleCourse)
{
string msg;
_Logger.DebugFormat("Importiere Raumreservierung: {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 Reservation
{
ExternalSource = "JSON",
ExternalId = scheduleCourse.CourseId,
Organiser = organiser,
ShortName = scheduleCourse.ShortName,
Name = scheduleCourse.Name,
Description = scheduleCourse.Description,
Occurrence = null,
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
// Eine Raumreservierung hat keine Gruppen
db.SaveChanges();
// 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 = null,
};
_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 = $"Raumreservierung {course.ShortName} mit Terminen importiert";
return(msg);
}
public string UpdateCourse(Course c, ScheduleCourse scheduleCourse)
{
string msg;
_Logger.DebugFormat("Aktualisiere Fach: {0}", scheduleCourse.Name);
_report.AppendFormat("<h1>Aktualisiere 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 = db.Activities.OfType <Course>().SingleOrDefault(x => x.Id == c.Id);
// Ober sticht Unter => zuerst alle termine raus!
_report.AppendLine("<h2>Gelöschte Termine</h2>");
_report.AppendLine("<table>");
foreach (var date in course.Dates.ToList())
{
_report.AppendLine("<tr>");
_report.AppendFormat("<td>{0}</td><td>{1}</td><td>{2}</td>", date.Begin.ToShortDateString(), date.Begin.ToShortTimeString(), date.End.ToShortTimeString());
_report.AppendLine("<td>");
foreach (var room in date.Rooms)
{
_report.AppendFormat("<p>{0}</p>", room.Number);
}
_report.AppendLine("</td>");
_report.AppendLine("<td>");
foreach (var host in date.Hosts)
{
_report.AppendFormat("<p>{0} ({1})</p>", host.Name, host.ShortName);
}
_report.AppendLine("</td>");
_report.AppendFormat("<td>{0}</td>", date.Title);
_report.AppendFormat("<td>{0}</td>", date.Description);
_report.AppendFormat("<td>{0}</td>", date.Occurrence.Information);
_report.AppendLine();
_report.AppendLine("</tr>");
db.Occurrences.Remove(date.Occurrence);
foreach (var change in date.Changes.ToList())
{
foreach (var notificationState in change.NotificationStates.ToList())
{
db.NotificationStates.Remove(notificationState);
change.NotificationStates.Remove(notificationState);
}
date.Changes.Remove(change);
db.DateChanges.Remove(change);
}
course.Dates.Remove(date);
db.ActivityDates.Remove(date);
}
db.SaveChanges();
_report.AppendLine("</table>");
// Die Bezeichnung
_report.AppendLine("<h2>Bezeichnungen</h2>");
_report.AppendLine("<h3>Alt</h3>");
_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>");
course.Name = scheduleCourse.Name;
course.ShortName = scheduleCourse.ShortName;
course.Description = scheduleCourse.Description;
_report.AppendLine("<h3>Neu</h3>");
_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>");
// Platzkontingent
course.Occurrence.Capacity = scheduleCourse.SeatRestriction ?? 0;
// Termine einfügen
// 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;
}
}
// Es muss Vorlesung sein und das Datum darf nicht existieren
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();
long msEnd = sw.ElapsedMilliseconds;
_Logger.DebugFormat("Dauer {0}ms", msEnd - msStart);
msg = $"Kurs {course.ShortName} mit Terminen aktualisiert";
return(msg);
}
public string GetStateMessage(OrganiserMember member)
{
var nSupervisors = Thesis.Supervisors.Count;
var didIAccepted = Thesis.Supervisors.Any(x => x.Member.Id == member.Id && x.AcceptanceDate.HasValue);
if (Thesis.IsCleared != null)
{
if (Thesis.IsCleared == true)
{
return("abgerechnet");
}
else
{
return("nicht abgerechnet");
}
}
if (Thesis.DeliveryDate != null)
{
if (Thesis.GradeDate != null)
{
return("Bereits bewertet");
}
return("Abgegeben, noch nicht bewertet");
}
if (nSupervisors == 1)
{
if (didIAccepted)
{
return("Arbeit angenommen");
}
return("Betreuungsanfrage");
}
var nAccepted = Thesis.Supervisors.Count(x => x.AcceptanceDate.HasValue);
if (nAccepted == 0)
{
return($"Betreuungsanfrage bei {nSupervisors} Lehrenden.");
}
if (didIAccepted)
{
if (nAccepted == 1)
{
return
($"Arbeit wurde von mir angenommen. Von {nSupervisors - 1} Lehrenden steht die Antwort noch aus.");
}
return($"Arbeit wurde von mir und {nAccepted - 1} Lehrenden angenommen.");
}
if (nAccepted > 0)
{
return($"Arbeit wurde bereits von {nAccepted} Lehrenden angenommen.");
}
return("Betreuungsanfrage");
}
/// <summary>
/// Persönlichen Token in der DB hinterlegen
/// </summary>
/// <param name="lecturer"></param>
/// <param name="semester"></param>
/// <returns></returns>
public ICollection <AvailableSlotModel> GetAvailabeSlots(OrganiserMember lecturer, Semester semester)
{
var db = new TimeTableDbContext();
var list = new List <AvailableSlotModel>();
var officeHour =
db.Activities.OfType <OfficeHour>().SingleOrDefault(a =>
a.Semester.Id == semester.Id &&
a.Dates.Any(oc => oc.Hosts.Any(l => l.Id == lecturer.Id)));
if (officeHour == null)
{
return(list);
}
var futureDates = officeHour.Dates.Where(x => x.Begin > DateTime.Now).OrderBy(x => x.Begin).ToList();
foreach (var date in futureDates)
{
if (date.Slots.Any())
{
// bin ich in in einem Slot eingetragen?
// ja => dazufügen (Status kommt später)
// nein => ist noch ein Platz frei
foreach (var slot in date.Slots)
{
var isSubscribed = false;
if (isSubscribed)
{
var ohSlot = new AvailableSlotModel
{
Begin = slot.Begin,
End = slot.End,
OccurrenceId = slot.Occurrence.Id,
IsSubscribed = true
};
list.Add(ohSlot);
}
else
{
if (slot.Occurrence.Capacity < 0)
{
// keine Platzbeschränkung
var ohSlot = new AvailableSlotModel
{
Begin = slot.Begin,
End = slot.End,
OccurrenceId = slot.Occurrence.Id
};
list.Add(ohSlot);
}
else if (slot.Occurrence.Subscriptions.Count < slot.Occurrence.Capacity)
{
// Platzbeschränkung mit noch freien Plätzen
var n = slot.Occurrence.Capacity - slot.Occurrence.Subscriptions.Count;
var ohSlot = new AvailableSlotModel
{
Begin = slot.Begin,
End = slot.End,
OccurrenceId = slot.Occurrence.Id,
Remark = string.Format("Noch {0} Plätze verfügbar", n)
};
list.Add(ohSlot);
}
}
}
}
else
{
var isSubscribed = false;
if (isSubscribed)
{
var ohSlot = new AvailableSlotModel
{
Begin = date.Begin,
End = date.End,
OccurrenceId = date.Occurrence.Id,
IsSubscribed = true
};
list.Add(ohSlot);
}
else
{
if (date.Occurrence.Capacity < 0)
{
var ohSlot = new AvailableSlotModel
{
Begin = date.Begin,
End = date.End,
OccurrenceId = date.Occurrence.Id
};
list.Add(ohSlot);
}
else if (date.Occurrence.Subscriptions.Count < date.Occurrence.Capacity)
{
var n = date.Occurrence.Capacity - date.Occurrence.Subscriptions.Count;
var ohSlot = new AvailableSlotModel
{
Begin = date.Begin,
End = date.End,
OccurrenceId = date.Occurrence.Id,
Remark = string.Format("Noch {0} Plätze verfügbar", n)
};
list.Add(ohSlot);
}
}
}
}
return(list);
}
