private Course GetCourse(TimeTableDbContext db, Semester sem, ActivityOrganiser org, CieCourse course)
{
// alle Kurse im Semester des Organisers nach dem Namen durchsuchen
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="userId"></param>
/// <param name="semester"></param>
/// <param name="org"></param>
/// <returns></returns>
public bool IsSubscribed(string userId, Semester semester, ActivityOrganiser org)
{
return(_db.Subscriptions.OfType <SemesterSubscription>().Any(s =>
s.UserId.Equals(userId) &&
s.SemesterGroup.Semester.Id.Equals(semester.Id) &&
s.SemesterGroup.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == org.Id));
}
public ICollection <Data.Curriculum> GetActiveCurricula(ActivityOrganiser org, Semester semester, bool availableOnly)
{
if (org == null)
{
return(new List <Data.Curriculum>());
}
if (availableOnly)
{
return
(_db.Curricula.Where(
x => x.Organiser.Id == org.Id &&
x.CurriculumGroups.Any(
y => y.CapacityGroups.Any(
z => z.SemesterGroups.Any(
k => k.IsAvailable && k.Semester.Id == semester.Id)
)))
.ToList());
}
return
(_db.Curricula.Where(
x => x.Organiser.Id == org.Id &&
x.CurriculumGroups.Any(
y => y.CapacityGroups.Any(
z => z.SemesterGroups.Any(
k => k.Semester.Id == semester.Id)
)))
.ToList());
}
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 async Task <IHttpActionResult> Get(Guid id)
{
ActivityOrganiser organiser = await Db.Organisers.FindAsync(id);
if (organiser == null)
{
return(NotFound());
}
var f = new Faculty
{
id = organiser.Id.ToString(),
name = organiser.Name,
shortname = organiser.ShortName,
curricula = new List <Curriculum>()
};
foreach (var curriculum in organiser.Curricula)
{
var c = new Curriculum
{
id = curriculum.Id.ToString(),
name = curriculum.Name,
shortname = curriculum.ShortName
};
f.curricula.Add(c);
}
return(Ok(f));
}
public ActionResult DeleteConfirmed(Guid id)
{
ActivityOrganiser activityorganiser = Db.Organisers.Find(id);
Db.Organisers.Remove(activityorganiser);
Db.SaveChanges();
return(RedirectToAction("Index", "OrganiserMembers"));
}
public ICollection <OrganiserMember> GetLecturers(ActivityOrganiser org, Semester sem)
{
var activeLecturers =
_db.Members.Where(m => m.Organiser.Id == org.Id)
.OrderBy(m => m.Name)
.ToList();
return(activeLecturers);
}
public ActionResult Edit([Bind(Include = "Id,Name,ShortName,HtmlColor,IsFaculty,IsStudent,IsVisible")] ActivityOrganiser activityorganiser)
{
if (ModelState.IsValid)
{
Db.Entry(activityorganiser).State = EntityState.Modified;
Db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(activityorganiser));
}
/// <summary>
/// Das neueste Semester, das Semestergruppen hat
/// </summary>
/// <param name="org"></param>
/// <returns></returns>
public Semester GetNewestSemester(ActivityOrganiser org)
{
var sem =
_db.Semesters
.Where(x => x.Groups.Any(g =>
g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == org.Id))
.OrderByDescending(x => x.StartCourses).FirstOrDefault();
return(sem ?? GetSemester(DateTime.Today));
}
public ICollection <Data.Semester> GetActiveSemester(ActivityOrganiser org)
{
if (org == null)
{
return(new List <Data.Semester>());
}
return
(_db.Semesters.Where(
x => x.Groups.Any(g => g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == org.Id)).ToList());
}
public ActionResult Create([Bind(Include = "Id,Name,ShortName")] ActivityOrganiser activityorganiser)
{
if (ModelState.IsValid)
{
activityorganiser.Id = Guid.NewGuid();
Db.Organisers.Add(activityorganiser);
Db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(activityorganiser));
}
public MemberUpdateService(string orgName)
{
_org = _db.Organisers.SingleOrDefault(x => x.ShortName.Equals(orgName));
foreach (var member in _org.Members)
{
var update = new MemberUpdate
{
Member = member
};
_member.Add(update);
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ActivityOrganiser activityorganiser = Db.Organisers.Find(id);
if (activityorganiser == null)
{
return(HttpNotFound());
}
return(View(activityorganiser));
}
public ICollection <ActivityDate> GetDates(DateTime atDateTime, ActivityOrganiser forOrganiser)
{
var nowPlaying = Db.ActivityDates.Where(d =>
(d.Begin <= atDateTime && atDateTime <= d.End) && // alles an diesem Tag
(d.Activity.SemesterGroups.Any(g => // alles was Zugehörigkeit zu einer Semestergruppe hat
g.CapacityGroup != null &&
g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == forOrganiser.Id) ||
(d.Activity.Organiser.Id == forOrganiser.Id) // alle Raumreservierungen, Sprechstunden
))
.OrderBy(d => d.Begin).ThenBy(d => d.End).ToList();
return(nowPlaying);
}
/// <summary>
///
/// </summary>
/// <param name="org"></param>
/// <returns></returns>
protected UserRight GetUserRight(ActivityOrganiser org)
{
var user = UserManager.FindByName(User.Identity.Name);
var member = org.Members.FirstOrDefault(m => !string.IsNullOrEmpty(m.UserId) && m.UserId.Equals(user.Id));
return(new UserRight
{
IsSysAdmin = User.IsInRole("SysAdmin"),
IsHost = false,
IsSubscriber = false,
User = user,
Member = member
});
}
public ActionResult Create(ActivityOrganiser model)
{
if (Db.Organisers.Any(x => x.ShortName.Equals(model.ShortName)))
{
ModelState.AddModelError("ShortName", "Ein Veranstalter mit diesem Kurznamen existiert schon.");
}
if (!ModelState.IsValid)
{
return(View(model));
}
model.Id = Guid.NewGuid();
Db.Organisers.Add(model);
Db.SaveChanges();
return(RedirectToAction("Index"));
}
private void Init(Guid?id)
{
_faculty = GetMyOrganisation();
_union = null;
if (id != null)
{
_union = GetOrganiser(id.Value);
}
else
{
var unionName = _faculty.ShortName.Replace("FK", "FS");
_union = GetOrganiser(unionName);
}
ViewBag.FacultyUserRight = GetUserRight(_faculty);
ViewBag.UnionUserRight = GetUserRight(_union);
}
public ActivityOrganiser AddOrganiser(string shortName, string name, bool isFaculty, bool isStudent)
{
var org = GetOrganiser(shortName);
if (org == null)
{
org = new ActivityOrganiser
{
ShortName = shortName,
Name = name,
IsFaculty = isFaculty,
IsStudent = isStudent
};
_db.Organisers.Add(org);
_db.SaveChanges();
}
return(org);
}
/// <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);
}
/// <summary>
///
/// </summary>
/// <param name="htmlHelper"></param>
/// <param name="org"></param>
/// <param name="icon"></param>
/// <returns></returns>
public static MvcHtmlString FacultyLabel(this HtmlHelper htmlHelper, ActivityOrganiser org, string icon = null)
{
var sb = new StringBuilder();
var color = string.IsNullOrEmpty(org.HtmlColor) ? "#ddd" : org.HtmlColor;
if (string.IsNullOrEmpty(icon))
{
sb.AppendFormat(
"<span class=\"label\" style=\"background-color: {0}; color: white\">{1}</span>",
color, org.ShortName);
}
else
{
sb.AppendFormat(
"<span class=\"label\" style=\"background-color: {0}; color: white\"><i class=\"fa {1}\"></i> {2}</span>",
color, icon, org.ShortName);
}
return(new MvcHtmlString(sb.ToString()));
}
private Room InitRoom(TimeTableDbContext db, Raum raum, ActivityOrganiser organiser)
{
var room = db.Rooms.FirstOrDefault(r => r.Number.Equals(raum.Nummer));
if (room == null)
{
room = new Room
{
Number = raum.Nummer,
Capacity = raum.Kapazitaet,
Description = raum.Beschreibung,
Owner = raum.Nutzer,
};
db.Rooms.Add(room);
db.SaveChanges();
_numRooms++;
}
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();
}
return(room);
}
public void CheckFaculty()
{
var db = new TimeTableDbContext();
_organiser = db.Organisers.SingleOrDefault(s => s.Id == _orgId);
_semester = db.Semesters.SingleOrDefault(s => s.Id == _semId);
// Anzahl der Semestergruppen, die zu meiner Fakultät passen
var countFacultyFit = _import.Model.Courses.Count(x =>
x.Groups != null &&
x.Groups.Any(g =>
!string.IsNullOrEmpty(g.FacultyName) &&
g.FacultyName.Equals(_organiser.ShortName)));
var countSemesterFit = _import.Model.Courses.Count(x =>
x.Groups != null &&
x.Groups.Any(g =>
!string.IsNullOrEmpty(g.SemesterName) &&
g.SemesterName.Equals(_semester.Name)));
// 0 geht gar nicht!
if (countFacultyFit == 0)
{
_import.AddErrorMessage("Import", $"keine Datem für {_organiser.ShortName}", true);
_isValid = false;
}
if (countSemesterFit == 0)
{
_import.AddErrorMessage("Import", $"keine Datem für {_semester.Name}", true);
_isValid = false;
}
if (_isValid)
{
_import.ValidCourses.AddRange(_import.Model.Courses);
}
}
private List <SemesterCourseViewModel> CreateSemesterReport(Semester semester, ActivityOrganiser org)
{
var userInfoService = new UserInfoService();
var model = new List <SemesterCourseViewModel>();
// Alle Lehrveranstaltungen in diesem Semester
var courses = Db.Activities.OfType <Course>().Where(x => x.SemesterGroups.Any(s =>
s.Semester.Id == semester.Id && s.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == org.Id))
.ToList();
// für jede Lehrveranstaltung alle Dozenten
foreach (var course in courses)
{
// Alle Dozenten in dieser LV
var lectures =
Db.Members.Where(l => l.Dates.Any(occ => occ.Activity.Id == course.Id)).ToList();
// Für jede Semestergruppe
foreach (var semesterGroup in course.SemesterGroups)
{
foreach (var lecture in lectures)
{
var courseModel = new SemesterCourseViewModel
{
Course = course,
Curriculum = semesterGroup.CapacityGroup.CurriculumGroup.Curriculum,
Lecturer = lecture,
User = userInfoService.GetUser(lecture.UserId),
Group = semesterGroup
};
model.Add(courseModel);
}
}
}
model = model.OrderBy(x => x.Curriculum.ShortName).ThenBy(x => x.Lecturer.Name).ToList();
return(model);
}
/// <summary>
///
/// </summary>
/// <param name="semesterName"></param>
/// <param name="searchString"></param>
/// <returns></returns>
public List <CourseSummaryModel> SearchCourses(Guid semesterId, string searchString, ActivityOrganiser organiser)
{
var semester = Db.Semesters.SingleOrDefault(l => l.Id == semesterId);
if (semester != null)
{
if (organiser != null)
{
var courses1 =
Db.Activities.OfType <Course>().Where(
c => c.SemesterGroups.Any(g => g.Semester.Id == semester.Id &&
(c.Name.ToUpper().Contains(searchString) ||
c.ShortName.ToUpper().Contains(searchString)) &&
(c.Dates.Any(d => d.Hosts.Any(h => h.Organiser.Id == organiser.Id))))
).OrderBy(c => c.Name).ToList();
var courses2 =
Db.Activities.OfType <Course>().Where(
c => c.SemesterGroups.Any(g => g.Semester.Id == semester.Id &&
(c.Dates.Any(d => d.Hosts.Any(h =>
h.Organiser.Id == organiser.Id &&
(h.Name.Contains(searchString) ||
h.ShortName.Contains(searchString))))))
).OrderBy(c => c.Name).ToList();
courses1.AddRange(courses2);
var courses = courses1.Distinct().ToList();
return(CreateCourseSummaries(courses));
}
else
{
var courses =
Db.Activities.OfType <Course>().Where(
c => c.SemesterGroups.Any(g => g.Semester.Id == semester.Id &&
(c.Name.ToUpper().Contains(searchString) ||
c.ShortName.ToUpper().Contains(searchString) ||
c.Dates.Any(
d =>
d.Hosts.Any(
h =>
h.Name.Contains(searchString) ||
h.ShortName.Contains(searchString)))))
).OrderBy(c => c.Organiser.ShortName).ToList();
return(CreateCourseSummaries(courses));
}
}
return(new List <CourseSummaryModel>());
}
