/// <summary>
/// Alle Vorlesungen eines Dozenten
/// </summary>
/// <param name="LecturerId"></param>
/// <returns></returns>
public LecturerCoursesContract GetLecturerCourses(string LecturerId)
{
var db = new TimeTableDbContext();
var lecturer = db.Members.Where(l => l.Id.ToString().Equals(LecturerId)).FirstOrDefault();
var lecturerCourseContract = new LecturerCoursesContract();
if (lecturer != null)
{
//Grundinfos
lecturerCourseContract.LecturerId = LecturerId;
lecturerCourseContract.LecturerName = lecturer.Name;
lecturerCourseContract.LecturerShortname = lecturer.ShortName;
var courseList = new List <LectureCourses>();
//Abfrage aller Kurse, bei dem der Dozent verwickelt ist
var courselist = db.Activities.OfType <Course>().Where(c =>
c.Dates.Any(oc => oc.Hosts.Any(l => l.Id.ToString() == LecturerId)))
.ToList();
foreach (var course in courselist)
{
courseList.Add(new LectureCourses
{
LectureId = course.Id.ToString(),
Title = course.Name,
});
}
lecturerCourseContract.LectureCourses = courseList.OrderBy(c => c.Title);
}
return(lecturerCourseContract);
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "Lecturers")
{
return(_dbContext.Lecturers.ToList());
}
else if (type == "Tags")
{
return(_dbContext.Tags.ToList());
}
else if (type == "Group")
{
return(_dbContext.GroupID.ToList());
}
else if (type == "SubGroup")
{
return(_dbContext.SubGroupID.ToList());
}
else if (type == "Subject")
{
return(_dbContext.Subjects.ToList());
}
else if (type == "Session")
{
return(_dbContext.Sessions.ToList());
}
return(null);
}
/// <summary>
/// Abfrage eines speziellen Events mit Hilfe der EventId
/// </summary>
/// <param name="eventId"></param>
/// <returns></returns>
public EventContract GetEvent(string eventId)
{
var db = new TimeTableDbContext();
var dbevent = db.Activities.FirstOrDefault(a => a.Id.ToString().Equals(eventId));
var eventinfo = new EventContract();
if (dbevent != null)
{
eventinfo.EventId = dbevent.Id.ToString();
eventinfo.EventName = dbevent.Name;
eventinfo.EventSlots = dbevent.Occurrence.Capacity;
eventinfo.EventDesciption = dbevent.Description;
eventinfo.AvailableSlots = (dbevent.Occurrence.Capacity - dbevent.Occurrence.Subscriptions.Count());
var eventDateList = new List <EventDate>();
foreach (var date in dbevent.Dates)
{
eventDateList.Add(new EventDate
{
Start = date.Begin.ToString("hh\\:mm"),
End = date.End.ToString("hh\\:mm"),
Date = date.Begin.Date.ToString("dd.MM.yyyy"),
PlaceName = date.Rooms.FirstOrDefault() != null ? date.Rooms.First().Number : "N.N.",
PlaceId = date.Rooms.FirstOrDefault() != null ? date.Rooms.First().Id.ToString() : "N.N.",
EventOrganiser = date.Hosts.FirstOrDefault() != null ? date.Hosts.First().Name : "N.N.",
});
}
eventinfo.Dates = eventDateList;
}
return(eventinfo);
}
public void CheckLecturers()
{
var db = new TimeTableDbContext();
var org = db.Organisers.SingleOrDefault(o => o.Id == _orgId);
if (org == null)
{
_import.AddErrorMessage("Import", "Unbekannte Organisationseinheit", true);
return;
}
foreach (var doz in _import.Dozenten.Where(d => d.IsTouched))
{
if (org.Members.Count(m => m.ShortName.Equals(doz.DozentID)) > 1)
{
_import.AddErrorMessage("Import", string.Format("Kurzname {0} existieren mehrfach in Datenbank. Dozent wird keinem Termin zugeordnet", doz.DozentID), true);
}
else
{
var lec = org.Members.SingleOrDefault(m => m.ShortName.Equals(doz.DozentID));
if (lec == null)
{
_import.AddErrorMessage("Import", string.Format("Dozent [{0} ({1})] existiert nicht in Datenbank. Wird bei Import automatisch angelegt.", doz.Name, doz.DozentID), false);
}
}
}
}
/*
* 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 void CheckRooms()
{
var db = new TimeTableDbContext();
var org = db.Organisers.SingleOrDefault(o => o.Id == _orgId);
if (org == null)
{
_import.AddErrorMessage("Import", "Unbekannte Organisationseinheit", true);
return;
}
foreach (var raum in _import.Raeume.Where(r => r.IsTouched))
{
var room = db.Rooms.SingleOrDefault(r => r.Number.Equals(raum.Nummer));
if (room == null)
{
_import.AddErrorMessage("Import",
$"Raum [{raum.Nummer}] existiert nicht in Datenbank. Raum wird bei Import automatisch angelegt und {org.ShortName} zugeordnet", false);
}
else
{
if (room.Assignments.All(a => a.Organiser.Id != org.Id))
{
_import.AddErrorMessage("Import",
$"Raum [{raum.Nummer}] existiert hat aber keine Zuordnung zu {org.ShortName}. Zuordnung wird bei Import automatisch angelegt.", false);
}
}
}
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "Groups")
{
return(_dbContext.Groups.AsNoTracking().ToList());
}
else if (type == "ASY")
{
return(_dbContext.ASY.AsNoTracking().ToList());
}
else if (type == "GroupID")
{
return(_dbContext.GroupID.AsNoTracking().ToList());
}
else if (type == "Rooms")
{
return(_dbContext.Rooms.AsNoTracking().ToList());
}
else if (type == "RoomsforConsectiveSession")
{
return(_dbContext.RoomsforConsectiveSession.AsNoTracking().ToList());
}
return(null);
}
private Course GetCourse(TimeTableDbContext db, Semester sem, ActivityOrganiser org, CieCourse course)
{
// alle Kurse im Semester des Organisers nach dem Namen durchsuchen
return(null);
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "Faculty")
{
return(_dbContext.Faculties.AsNoTracking().ToList());
}
else if (type == "Department")
{
return(_dbContext.Departments.AsNoTracking().ToList());
}
else if (type == "Center")
{
return(_dbContext.Centers.AsNoTracking().ToList());
}
else if (type == "Building")
{
return(_dbContext.Buildings.AsNoTracking().ToList());
}
else if (type == "Level")
{
return(_dbContext.EmployeeLevels.AsNoTracking().ToList());
}
else if (type == "Lecturers")
{
return(_dbContext.Lecturers.AsNoTracking().ToList());
}
return(null);
}
public void RoomAdd()
{
TimeTableDbContext db = TestDataService.GetDataContext();
//Testen ob wirklich nur 1 Raum in der Datenbank ist
int n2 = db.Rooms.Count();
Assert.AreEqual(1, n2);
// Neuen Raum hinzufügen
Room r2 = new Room()
{
Name = "Computerlabor",
Number = "R BG.089 "
};
db.Rooms.Add(r2);
// Schreib es in die Datenbank
db.SaveChanges();
// Zähle ob jetzt 2 Räume da sind
var db3 = new TimeTableDbContext();
int n3 = db3.Rooms.Count();
Assert.AreEqual(2, n3);
}
public DashboardFunction(Panel _appPanel, Panel _formPanel)
{
_db = new TimeTableDbContext();
AppPanel = _appPanel;
FormPanel = _formPanel;
LoadAppForms();
}
/// <summary>
/// Dozenten deren Name/vorname mit x startet einer Fakultät
/// </summary>
/// <param name="Startswith"></param>
/// <param name="orgName"></param>
/// <returns></returns>
public IEnumerable <LecturerContract> GetLecturersStartwith(string Startswith, string orgName)
{
var db = new TimeTableDbContext();
//Member sind alle Organisationsmitglieder?
var lecturers = db.Members.Where(l => l.ShortName.StartsWith(Startswith) ||
l.Name.StartsWith(Startswith) &&
l.Organiser.ShortName.Equals(orgName));
var lecturerContract = new List <LecturerContract>();
foreach (var lecturer in lecturers)
{
if (lecturer != null)
{
lecturerContract.Add(new LecturerContract
{
LecturerId = lecturer.Id.ToString(),
LecturerName = lecturer.Name,
LecturerShortname = lecturer.ShortName,
});
}
}
return(lecturerContract.OrderBy(l => l.LecturerName));
}
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);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult GetDocument(Guid id)
{
var db = new TimeTableDbContext();
var file = db.Storages.SingleOrDefault(img => img.Id == id);
return File(file.BinaryData, file.FileType, file.Name);
}
public SubjectsFormModel GetId(SubjectsFormModel obj)
{
TimeTableDbContext _dbContext = new TimeTableDbContext();
int exitCount = _dbContext.Subjects.Count() + 1;
obj.SubjectCode = "SUB" + exitCount.ToString().PadLeft(4, '0');
return(obj);
}
internal ICollection <Course> GetAllLottryCourses(Semester semester)
{
var Db = new TimeTableDbContext();
return(Db.Activities.OfType <Course>().Where(c =>
c.Occurrence.LotteryEnabled &&
c.SemesterGroups.Any(g => g.Semester.Id == semester.Id)).ToList());
}
public void CourseSubscritpions()
{
TimeTableDbContext db = TestDataService.GetDataContext();
Course c1 = db.Activities.OfType <Course>().SingleOrDefault(a1 => a1.ShortName.Equals("TM"));
Course c2 = db.Activities.OfType <Course>().SingleOrDefault(a2 => a2.ShortName.Equals("Info"));
}
internal int GetNextPriority(Semester semester, string userId)
{
var Db = new TimeTableDbContext();
// Alle WPM-Subscriptions für den User holen und nach Prio und Datum sortieren
// alle Subscriptions durchgehen und Reihenfolge prüfen
// ggf. Prio setzen
// neue Prio ermitteln
var wpmList = Db.Activities.OfType <Course>().Where(a =>
a.Occurrence.Subscriptions.Any(u => u.UserId.Equals(userId)) &&
a.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
a.SemesterGroups.Any(g => g.CapacityGroup.CurriculumGroup.Name.Equals("WPM"))).ToList();
var subList = new List <SubscriptionCourseViewModel>();
foreach (var wpm in wpmList)
{
// es könnten ja auch mehrere Eintragungen vorliegen
var wpmsubs = wpm.Occurrence.Subscriptions.Where(s => s.UserId.Equals(userId));
foreach (var subscription in wpmsubs)
{
subList.Add(new SubscriptionCourseViewModel
{
SubscriptionId = subscription.Id,
Course = wpm,
Priority = subscription.Priority.HasValue ? subscription.Priority.Value : 999,
SubscriptionTotalCount = wpm.Occurrence.Subscriptions.Count,
SubscriptionPrio1Count = wpm.Occurrence.Subscriptions.Count(s => s.Priority == 1),
SubscriptionPrio2Count = wpm.Occurrence.Subscriptions.Count(s => s.Priority == 2),
Capacity = wpm.Occurrence.Capacity,
SubscriptionDateTime = subscription.TimeStamp,
});
}
}
var orderdSubList = subList.OrderBy(item => item.Priority).ThenBy(item => item.SubscriptionDateTime);
// Hypothese: alle sind nach Prio und ohne Löcher geordnet
// zur Sicherheit hier alles durchgehen!
var prio = 1;
foreach (var item in orderdSubList)
{
if (item.Priority == 999 || item.Priority != prio)
{
var subscription = Db.Subscriptions.OfType <OccurrenceSubscription>().SingleOrDefault(s => s.Id == item.SubscriptionId);
subscription.Priority = prio;
Db.SaveChanges();
}
prio++;
}
return(orderdSubList.Count() + 1);
}
public LecturersFormModel GetId(LecturersFormModel obj)
{
TimeTableDbContext _dbContext = new TimeTableDbContext();
int exitCount = _dbContext.Lecturers.Count() + 1;
obj.EmployeeId = exitCount.ToString().PadLeft(6, '0');
obj.Rank = obj.EmployeeLevel + "." + obj.EmployeeId;
return(obj);
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "Programme")
{
return(_dbContext.Programme.AsNoTracking().ToList());
}
return(null);
}
public static TimeTableDbContext GetDataContext()
{
if (_ctx == null)
{
_ctx = new TimeTableDbContext();
InitTestData();
}
return(_ctx);
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "WorkingDays")
{
return(_dbContext.WorkingDays.AsNoTracking().ToList());
}
return(null);
}
/// <summary>
/// Löscht alle Kurse aus dem angegebenen Semester, die aus gpUntis importiert wurden
/// </summary>
/// <param name="semId"></param>
/// <param name="orgId"></param>
public void DeleteSemester(Guid semId, Guid orgId)
{
var db = new TimeTableDbContext();
var semService = new SemesterService();
var timeTableService = new TimeTableInfoService(db);
var msg = "Sammle Daten";
var perc1 = 0;
Clients.Caller.updateProgress(msg, perc1);
var semester = semService.GetSemester(semId);
if (semester == null)
{
msg = "Semester existiert nicht";
perc1 = 100;
Clients.Caller.updateProgress(msg, perc1);
return;
}
var courses = db.Activities.OfType <Course>().Where(c =>
c.Organiser.Id == orgId && // Veranstalter
(c.SemesterGroups.Any(g => // Mit Semestergruppe
g.Semester.Id == semId &&
g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == orgId) ||
!c.SemesterGroups.Any() // oder ohne Zuordnung
) &&
(!string.IsNullOrEmpty(c.ExternalSource) && c.ExternalSource.Equals("GPUNTIS"))) // aus GPUNTIS
.ToList();
msg = string.Format("Lösche {0} von {1} Kursen", courses.Count, courses.Count);
perc1 = 0;
Clients.Caller.updateProgress(msg, perc1);
var n = courses.Count;
var i = 0;
foreach (var course in courses)
{
i++;
msg = string.Format("Lösche {0}", course.Name);
perc1 = (i * 100) / n;
Clients.Caller.updateProgress(msg, perc1);
timeTableService.DeleteCourse(course.Id);
}
msg = "Alle Kurse gelöscht";
perc1 = 100;
Clients.Caller.updateProgress(msg, perc1);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IEnumerable <EventContract> GetAllEvents()
{
var db = new TimeTableDbContext();
var now = DateTime.Now;
//alle zukünftigen Events
var events = db.Activities.OfType <Event>()
.Where(ev => ev.Dates.Any(d => d.End >= now)).ToList();
//andere ansatz
//var events = db.Activities.OfType<Event>()
//.Where(ev => ev.Published == true && ev.Dates.Any(d => d.End >= now)).ToList();
var eventList = new List <EventContract>();
//jedes zukünftige event soll hinzugefügt werden mit Datum um Veranstalter
foreach (var @event in events)
{
var nextEvent = new EventContract
{
EventId = @event.Id.ToString(),
EventName = @event.Name,
EventDesciption = @event.Description,
//geht des so?
EventSlots = @event.Occurrence.Capacity,
AvailableSlots = @event.Occurrence.Capacity - @event.Occurrence.Subscriptions.Count(),
};
//Die einzelnen Termine der Veranstaltung
var eventDateList = new List <EventDate>();
//Alle Termine der Veranstaltung in der Zukunft
foreach (var date in @event.Dates)
{
//nur zukünftige Termine oder in zukuft reichende
if (date.Begin >= now || (date.Begin <= now && date.End > now))
{
eventDateList.Add(new EventDate
{
Start = date.Begin.ToString("hh\\:mm"),
End = date.End.ToString("hh\\:mm"),
Date = date.Begin.Date.ToString("dd.MM.yyyy"),
PlaceName = date.Rooms.FirstOrDefault() != null ? date.Rooms.First().Number : "N.N.",
PlaceId = date.Rooms.FirstOrDefault() != null ? date.Rooms.First().Id.ToString() : "N.N.",
EventOrganiser = date.Hosts.FirstOrDefault() != null ? date.Hosts.First().Name : "N.N.",
});
nextEvent.Dates = eventDateList;
}
}
eventList.Add(nextEvent);
}
//return eventList.OrderBy(ev => ev.Dates.First(e => e.Start>=now));
return(eventList);
}
public string ImportLottery(CourseLottery lottery)
{
string msg;
_Logger.DebugFormat("Importiere Lotterie: {0}", lottery.Name);
var db = new TimeTableDbContext();
var organiser = db.Organisers.SingleOrDefault(s => s.Id == _orgId);
var sem = db.Semesters.SingleOrDefault(s => s.Id == _semId);
var dbLottery = db.Lotteries.FirstOrDefault(x =>
x.Name.Equals(lottery.Name) &&
x.Semester != null && x.Semester.Id == sem.Id &&
x.Organiser != null && x.Organiser.Id == organiser.Id);
if (dbLottery == null)
{
dbLottery = new TimeTable.Data.Lottery
{
Name = lottery.Name,
DrawingFrequency = DrawingFrequency.Daily,
DrawingTime = lottery.FirstDrawing.TimeOfDay,
FirstDrawing = lottery.FirstDrawing,
LastDrawing = lottery.LastDrawing,
JobId = string.Empty,
Organiser = organiser,
Semester = sem,
MaxConfirm = lottery.SlotCount,
Description = string.Empty
};
db.Lotteries.Add(dbLottery);
db.SaveChanges();
}
// ok: im Augenblick gehen wir davon aus, dass als externe ID die LehrveranID aus vdb_t07 kommt
// damit müssten alle importieren Kurse eindeutig identifizierbar sein
foreach (var lotteryLot in lottery.Lots)
{
var course = db.Activities.OfType <Course>().FirstOrDefault(x =>
x.ExternalId.Equals(lotteryLot.CourseId) &&
x.SemesterGroups.Any(g => g.Semester.Id == sem.Id && g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == organiser.Id));
if (course != null)
{
dbLottery.Occurrences.Add(course.Occurrence);
}
}
db.SaveChanges();
msg = $"Lotterie {lottery.Name} importiert";
return(msg);
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "Groups")
{
return(_dbContext.Groups.AsNoTracking().ToList());
}
else if (type == "ASY")
{
return(_dbContext.ASY.AsNoTracking().ToList());
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public NextEventContract GetNextEvent(Guid id)
{
var db = new TimeTableDbContext();
var currentEvent = db.Activities.OfType <Event>().SingleOrDefault(ev => ev.Id == id);
var now = DateTime.Now.AddMinutes(-1);
// Gib mir von dem Event das Ende des nächsten Termins in der Zukunft
var currentDate = currentEvent.Dates.Where(d => d.End >= now).OrderBy(d => d.End).FirstOrDefault();
// Gib mir jetzt das Event, mit dem zeitlich am nächst gelegenen Beginn zum aktuellen Datum
var eventList =
db.Activities.OfType <Event>()
.Where(ev => ev.Published == true && ev.Id != id &&
ev.Dates.Any(d => d.End >= currentDate.Begin)).ToList();
ActivityDate nextDate = null;
foreach (var @event in eventList)
{
var testDate = @event.Dates.Where(d => d.End >= now).OrderBy(d => d.Begin).FirstOrDefault();
if (nextDate == null)
{
nextDate = testDate;
}
else
{
if (testDate.Begin < nextDate.Begin)
{
nextDate = testDate;
}
}
}
if (nextDate == null)
{
return(GetNextEvent());
}
var nextEvent = new NextEventContract
{
EventId = nextDate.Activity.Id,
Title = nextDate.Activity.Name,
Description = nextDate.Activity.Description,
From = nextDate.Begin,
Location = nextDate.Rooms.Any() ? nextDate.Rooms.First().Number : string.Empty,
};
return(nextEvent);
}
/// <summary>
/// Alle zukünftigen Sprechstunden bis Zeitpunkt
/// </summary>
/// <param name="until"></param>
/// <returns></returns>
public IEnumerable <LecturerOfficeHourContract> GetAllOfficehours(DateTime until)
{
var db = new TimeTableDbContext();
//Alle Sprechstunden
var officeHours = db.Activities.OfType <OfficeHour>().ToList();
var officeHourContract = new List <LecturerOfficeHourContract>();
foreach (var officeHour in officeHours)
{
//Nur buchbaren zukünftige Termine bis gewälten Zeitpunkt
var nextDate = officeHour.Dates.Where(oc => oc.Begin >= DateTime.Now && oc.Begin <= until && oc.Occurrence.IsAvailable).OrderBy(oc => oc.Begin).ToList();
if (nextDate != null)
{
foreach (var date in nextDate)
{
var officehourDate = new LecturerOfficeHourContract();
officehourDate.LecturerId = date.Hosts.FirstOrDefault() != null?date.Hosts.First().Id.ToString() : "N.N.";
officehourDate.LecturerName = date.Hosts.FirstOrDefault() != null?date.Hosts.First().Name : "N.N.";
//Steht der prof beim Raum als Owner drin?
officehourDate.LecturerRoomId = date.Rooms.Where(r => r.Owner == officehourDate.LecturerName).FirstOrDefault() != null?date.Hosts.First().Id.ToString() : "N.N.";
officehourDate.LecturerRoomNumber = date.Rooms.Where(r => r.Owner == officehourDate.LecturerName).FirstOrDefault() != null?date.Hosts.First().Name : "N.N.";
var officehourSlots = new List <LecturerOfficeHourDateSlot>();
foreach (var slot in date.Slots)
{
officehourSlots.Add(new LecturerOfficeHourDateSlot
{
OfficeHourSlotId = slot.Id.ToString(),
from = slot.Begin,
until = slot.End,
NumberOfPossibleSubscribers = slot.Occurrence.Capacity,
CurrentNumberOfSubscribers = slot.Occurrence.Subscriptions.Count(c => c.Id.ToString() != null),
isBookablefrom = slot.Occurrence.FromDateTime,
isBookableuntil = slot.Occurrence.UntilDateTime,
});
}
officehourDate.OfficeHours = officehourSlots;
officeHourContract.Add(officehourDate);
}
}
}
return(officeHourContract.OrderBy(oh => oh.LecturerName));
}
public dynamic GetFormData(TimeTableDbContext _dbContext, string type)
{
if (type == "Subjects")
{
return(_dbContext.Subjects.ToList());
}
if (type == "Year")
{
return(_dbContext.ASY.Select(year => year.Year).Distinct().ToList());
}
return(null);
}
public void TestFail()
{
TimeTableDbContext db = TestDataService.GetDataContext();
//neue Datenbankverknüpfunt
var db2 = new TimeTableDbContext();
//Zählt angelegt Räume
int n2 = db2.Rooms.Count();
//Muss 1 sein
Assert.AreEqual(1, n2);
}
public ActionResult CustomOccurrenceMail(OccurrenceMailingModel model)
{
var logger = LogManager.GetLogger("OccurrenceMail");
if (ModelState.IsValid)
{
var db = new TimeTableDbContext();
var occ = db.Occurrences.SingleOrDefault(c => c.Id == model.OccurrenceId);
if (occ != null)
{
// Liste der Empfänger ermitteln
var ac = new ActivityService();
var summary = ac.GetSummary(model.OccurrenceId);
var subscribers = summary.Subscriptions;
var users = new List <ApplicationUser>();
foreach (var subscription in subscribers)
{
var user = UserManager.FindById(subscription.UserId);
if (user != null)
{
users.Add(user);
}
}
// Mail an Teilnehmer einer Veranstaltung
// durch selbstständiges Eintragen automatisch Erhalt von Mails gewährleisten
model.IsImportant = true;
model.IsDistributionList = false;
model.ListName = summary.Name;
SendMail(users, model);
return(RedirectToAction("MailSentSuccess", "Mailing", new { id = model.OccurrenceId }));
}
else
{
logger.ErrorFormat("Occurrence {0} does not exist", model.OccurrenceId);
return(RedirectToAction("MailSentError", "Mailing"));
}
}
else
{
ViewBag.ErrorMessage = "Fehler im Formular: " + ModelState.ToString();
return(View("InvalidModel"));
}
}
