public ActionResult Curriculum(Guid curId, Guid semId)
{
var semester = SemesterService.GetSemester(semId);
var curriclum = Db.Curricula.SingleOrDefault(x => x.Id == curId);
var courses = Db.Activities.OfType <Course>().Where(x =>
x.SemesterGroups.Any(g =>
g.Semester.Id == semId && g.CapacityGroup.CurriculumGroup.Curriculum.Id == curId)).ToList();
var model = new SemesterActiveViewModel
{
Semester = semester,
Curriculum = curriclum,
};
var courseService = new CourseService(Db);
foreach (var course in courses)
{
var summary = courseService.GetCourseSummary(course);
model.Courses.Add(summary);
}
return(View(model));
}
public ActionResult Index()
{
var user = GetCurrentUser();
var model = new HomeViewModel();
// Alle Semester mit veröffentlichten Semestergruppen
var allPublishedSemester = Db.Semesters.Where(x => x.Groups.Any()).OrderByDescending(s => s.EndCourses).Take(4).ToList();
foreach (var semester in allPublishedSemester)
{
var isStaff = user.MemberState == MemberState.Staff;
var activeOrgs = SemesterService.GetActiveOrganiser(semester, !isStaff);
var semModel = new SemesterActiveViewModel
{
Semester = semester,
Organisers = activeOrgs.ToList()
};
model.ActiveSemester.Add(semModel);
}
ViewBag.UserRight = GetUserRight();
return(View(model));
}
public ActionResult Group(Guid semId, Guid groupId)
{
var user = GetCurrentUser();
var semester = SemesterService.GetSemester(semId);
var capGroup = Db.CapacityGroups.SingleOrDefault(x => x.Id == groupId);
var semGroup =
Db.SemesterGroups.FirstOrDefault(x =>
x.CapacityGroup.Id == capGroup.Id && x.Semester.Id == semester.Id);
if (user.MemberState != MemberState.Staff && !semGroup.IsAvailable)
{
return(View("NotAvailable", semGroup));
}
var allTopics = Db.SemesterTopics
.Where(x => x.Activities.Any(s => s.SemesterGroups.Any(g => g.Id == semGroup.Id))).ToList();
var model = new SemesterActiveViewModel
{
Semester = semester,
Organiser = capGroup.CurriculumGroup.Curriculum.Organiser,
Curriculum = capGroup.CurriculumGroup.Curriculum,
CapacityGroup = capGroup,
SemesterGroup = semGroup
};
return(View(allTopics.Any() ? "GroupByTopic" : "Group", model));
}
/// <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"));
}
public AllSingleCourse()
{
InitializeComponent();
var semesterItems = SemesterService.GetCount().OrderBy(c => c.Id).ToList();
var levels = LevelService.GetCount().OrderBy(c => c.Id).ToList();
ddLevel.DataSource = levels.Select(c => c.Name);
ddlSemester.DataSource = semesterItems.ToList().Select(c => c.Name);
ddLevel.SelectedIndexChanged += ddLevel_SelectedIndexChanged;
ddlSemester.SelectedIndexChanged += ddlSemester_SelectedIndexChanged;
LevelId = LevelService.GetLevelId((string)ddLevel.SelectedValue).Id;
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
ddlCourse.SelectedIndexChanged += (sender, args) =>
{
var model = CourseService.GetCourseByName((string)ddlCourse.SelectedValue);
if (model != null)
{
CourseId = model.Id;
}
};
ProcessCourseDataSourse(LevelId, SemesterId);
gridSingleStudentResult.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;
gridSingleStudentResult.AllowEditRow = true;
}
public IQueryable <SubscriptionDto> Subscriptions([FromBody] SubscriptionCourseModel model)
{
var studService = new StudentService(Db);
var semService = new SemesterService(Db);
var list = new List <SubscriptionDto>();
var user = GetUser(model.Id.ToString());
var student = studService.GetCurrentStudent(user.Id);
var semester = semService.GetSemester(DateTime.Today);
var courses = Db.Activities.OfType <Course>().Where(a =>
a.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
a.Occurrence.Subscriptions.Any(u => u.UserId.Equals(user.Id))).ToList();
foreach (var course in courses)
{
var subscription =
course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(user.Id));
var subModel = new SubscriptionDto();
subModel.CourseId = course.Id;
subModel.IsValid = true;
subModel.OnWaitingList = subscription.OnWaitingList;
subModel.Title = course.Name;
list.Add(subModel);
}
return(list.AsQueryable());
}
public IQueryable <SubscriptionDto> Courses([FromBody] SubscriptionCourseModel model)
{
var memberService = new MemberService(Db);
var semService = new SemesterService(Db);
var teachingService = new TeachingService(Db);
var list = new List <SubscriptionDto>();
var user = GetUser(model.Id.ToString());
var members = memberService.GetFacultyMemberships(user.Id);
var semester = semService.GetSemester(DateTime.Today);
var teaching = teachingService.GetActivities(semester, user, members);
foreach (var course in teaching.Courses)
{
var subModel = new SubscriptionDto();
subModel.CourseId = course.Course.Id;
subModel.Title = course.Course.Name;
list.Add(subModel);
}
return(list.AsQueryable());
}
public ActionResult Issue(ThesisAcceptModel model)
{
var subscription = Db.Subscriptions.OfType <OccurrenceSubscription>().SingleOrDefault(x => x.Id == model.Subscription.Id);
var supervision = Db.Activities.OfType <Supervision>()
.SingleOrDefault(x => x.Occurrence.Id == subscription.Occurrence.Id);
var user = GetUser(subscription.UserId);
// aus der subscription eine Thesis machen
var subInfoService = new SemesterSubscriptionService();
var semester = SemesterService.GetSemester(DateTime.Today);
var curriculum = subInfoService.GetBestCurriculum(subscription.UserId, semester);
int period = 0;
bool success = int.TryParse(curriculum.Version, out period);
if (!success || period == 0)
{
period = 3;
}
var student = Db.Students.FirstOrDefault(x => x.UserId.Equals(user.Id) && x.Curriculum.Id == curriculum.Id);
if (student == null)
{
var curr = Db.Curricula.SingleOrDefault(x => x.Id == curriculum.Id);
student = new Student
{
UserId = user.Id,
Curriculum = curr
};
Db.Students.Add(student);
}
var thesis = new Thesis();
thesis.TitleDe = model.Title;
thesis.Supervision = supervision;
thesis.IssueDate = DateTime.Today;
thesis.ExpirationDate = thesis.IssueDate.Value.AddMonths(period);
thesis.Student = student;
Db.Theses.Add(thesis);
// Subscription und alle anderen löschen
var list = Db.Activities.OfType <Supervision>().Where(x =>
x.Occurrence.Subscriptions.Any(u => u.UserId.Equals(subscription.UserId))).ToList();
foreach (var item in list)
{
var sub = item.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(user.Id));
Db.Subscriptions.Remove(sub);
}
Db.SaveChanges();
// oder zur Detailseite
return(RedirectToAction("Thesis", "Lecturer"));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult DeleteAll()
{
var today = DateTime.Today;
var semesterService = new SemesterService();
var thisSemester = semesterService.GetSemester(today);
var lastDate = thisSemester.StartCourses.AddDays(-1);
var changes = Db.DateChanges.Where(x => x.TimeStamp <= lastDate).ToList();
foreach (var change in changes)
{
change.Date?.Changes.Remove(change);
var notifications = change.NotificationStates.ToList();
foreach (var notification in notifications)
{
Db.NotificationStates.Remove(notification);
}
Db.DateChanges.Remove(change);
}
Db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Subscribe(Guid id)
{
var semester = SemesterService.GetSemester(id);
var semSubService = new SemesterSubscriptionService(Db);
// Liegt eine Einschreibung vor?
var semGroup = semSubService.GetSemesterGroup(AppUser.Id, semester);
SemesterSubscriptionViewModel model;
if (semGroup == null)
{
model = GetModel(semester);
}
else
{
model = new SemesterSubscriptionViewModel
{
Group = semGroup,
Semester = semester.Id.ToString()
};
}
ViewBag.Semester = semester;
return(View("Semester", model));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult List()
{
var semester = SemesterService.GetSemester(DateTime.Today);
var org = GetMyOrganisation();
var model = new ThesisOverviewModel
{
Semester = semester,
Organiser = org
};
var thesis = Db.Activities.OfType <Exam>().Where(oh =>
oh.SemesterGroups.Any(x => x.Semester.Id == semester.Id) &&
oh.Owners.Any(m => m.Member.Organiser.Id == org.Id))
.ToList();
foreach (var thesi in thesis)
{
var tm = new ThesisOfferViewModel
{
Thesis = thesi,
Curriculum = thesi.SemesterGroups.First().CapacityGroup.CurriculumGroup.Curriculum,
Lecturer = thesi.Owners.First().Member
};
model.Thesis.Add(tm);
}
ViewBag.UserRight = GetUserRight(org);
return(View(model));
}
/// <summary>
///
/// </summary>
protected BaseController()
{
ActivityService = new ActivityService(Db);
SemesterService = new SemesterService(Db);
DeleteService = new CascadingDeleteService(Db);
StudentService = new StudentService(Db);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public FileResult ParticipiantList(Guid id)
{
var summary = ActivityService.GetSummary(id);
var logger = LogManager.GetLogger("SubscriptionList");
logger.InfoFormat("List for [{0}]", summary.Activity.Name);
var semester = SemesterService.GetSemester(DateTime.Today);
var ms = new MemoryStream();
var writer = new StreamWriter(ms, Encoding.Default);
writer.Write(
"Name;Vorname;Studiengang;Semester;Status;E-Mail");
writer.Write(Environment.NewLine);
foreach (var subscription in summary.Subscriptions.Where(x => !x.OnWaitingList).OrderBy(s => s.TimeStamp))
{
var user = UserManager.FindById(subscription.UserId);
if (user != null)
{
var student = StudentService.GetCurrentStudent(user);
var group = "";
var sem = "";
if (student != null)
{
group = student.Curriculum.ShortName;
sem = student.FirstSemester.Name;
}
var subState = subscription.OnWaitingList ? "Warteliste" : "Teilnehmer";
writer.Write("{0};{1};{2};{3};{4};{5}",
user.LastName, user.FirstName,
group, sem,
subState,
user.Email);
writer.Write(Environment.NewLine);
}
}
writer.Flush();
writer.Dispose();
var sb = new StringBuilder();
sb.Append("Teilnehmer_");
sb.Append(summary.Activity.ShortName);
sb.Append("_");
sb.Append(DateTime.Today.ToString("yyyyMMdd"));
sb.Append(".csv");
return(File(ms.GetBuffer(), "text/csv", sb.ToString()));
}
public async Task <ActionResult> Index()
{
var user = await UserService.GetUserByIdAsync(User.GetId());
if (user == null)
{
return(HttpNotFound());
}
var semester = await SemesterService.GetCurrentSemesterAsync();
var themes = await ThemeService.GetThemesAsync(new ThemeFilter { AuthorId = user.Id });
var model = Mapper.Map <UserModel, ProfileViewModel>(user);
if (user.GroupId.HasValue)
{
var subjects = await SubjectService.GetSubjectsAsync(user.GroupId.Value, semester.Id);
var group = await GroupService.GetGroupAsync(user.GroupId.Value);
model.Subjects = Mapper.Map <PagedList <SubjectModel>, PagedList <SubjectViewModel> >(subjects);
model.Group = Mapper.Map <GroupModel, GroupViewModel>(group);
}
model.Themes = Mapper.Map <PagedList <ThemeModel>, PagedList <ThemeViewModel> >(themes);
return(View(model));
}
/// <summary>
/// Notenmeldung erfolgt
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult SendMark(Guid id)
{
// an den Stduierenden eine E-Mail mit Kopien an
// Betreuer
// Aktuellen Benutzer
var userService = new UserInfoService();
var user = GetCurrentUser();
var thesis = Db.Theses.SingleOrDefault(x => x.Id == id);
thesis.GradeDate = DateTime.Today;
// Annahme: Damit ist auch das Studium beendet
var sem = SemesterService.GetSemester(DateTime.Today);
thesis.Student.LastSemester = sem;
Db.SaveChanges();
// Mail an Studierenden
var model = InitMailModel(thesis, user);
new MailController().ThesisMarkedEMail(model).Deliver();
return(RedirectToAction("Done"));
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="semId"></param>
/// <returns></returns>
public ActionResult Schedule(Guid id, Guid?semId)
{
var member = Db.Members.SingleOrDefault(m => m.Id == id);
ViewBag.Semester = SemesterService.GetSemester(semId);
return(View("PersonalSchedule", member));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult OfficeHour(Guid?id)
{
var semester = SemesterService.GetSemester(id);
var member = GetMyMembership();
var officeHour = Db.Activities.OfType <OfficeHour>().FirstOrDefault(x =>
x.Semester.Id == semester.Id && x.Owners.Any(y => y.Member.Id == member.Id));
var infoService = new OfficeHourInfoService(UserManager);
if (officeHour == null)
{
return(RedirectToAction("Create", "OfficeHour", new { id = semester.Id }));
}
var model = new OfficeHourSubscriptionViewModel
{
OfficeHour = officeHour,
Semester = semester,
Host = infoService.GetHost(officeHour),
};
if (officeHour.ByAgreement)
{
return(View("DateListAgreement", model));
}
model.Dates.AddRange(infoService.GetDates(officeHour));
return(View("DateList", model));
}
public ActionResult SwitchCurriculum(CurriculumSubscriptionViewModel model)
{
var student = Db.Students.SingleOrDefault(x => x.Id == model.Student.Id);
var user = UserManager.FindById(student.UserId);
var curr = Db.Curricula.SingleOrDefault(x => x.Id == model.CurrId);
var semester = Db.Semesters.SingleOrDefault(x => x.Id == model.SemId);
// Das ist jetzt ein neuer Studiengang
// Zuerst den alten Studiengang beenden
var lastSemester = SemesterService.GetPreviousSemester(semester);
student.LastSemester = lastSemester;
var studentNew = new Student();
studentNew.UserId = user.Id;
studentNew.Created = DateTime.Now;
studentNew.Curriculum = curr;
studentNew.FirstSemester = semester;
studentNew.IsDual = model.IsDual;
studentNew.IsPartTime = model.IsPartTime;
Db.Students.Add(studentNew);
Db.SaveChanges();
return(RedirectToAction("Details", new { id = user.Id }));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
var org = GetMyOrganisation();
var semester = SemesterService.GetSemester(DateTime.Today);
var model = new SemesterImportModel
{
Semester = semester,
FirstDate = semester.StartCourses.ToShortDateString(),
LastDate = semester.EndCourses.ToShortDateString(),
Organiser = org,
SemesterId = semester.Id,
OrganiserId = org.Id,
Existing = GetCourseCount(org.Id, semester.Id)
};
ViewBag.Semester = Db.Semesters
.Where(x => x.EndCourses >= DateTime.Today && x.Groups.Any())
.OrderBy(s => s.StartCourses)
.Select(c => new SelectListItem
{
Text = c.Name,
Value = c.Id.ToString(),
});
return(View(model));
}
/// <summary>
///
/// </summary>
public ActionResult PersonalPlanList(Guid id)
{
var semester = SemesterService.GetSemester(id);
var user = AppUser;
var courseService = new CourseService(Db);
var model = new DashboardStudentViewModel();
model.Semester = semester;
model.User = user;
model.Student = StudentService.GetCurrentStudent(user);
model.Courses = new List <CourseSummaryModel>();
var courses = Db.Activities.OfType <Course>().Where(a =>
a.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
a.Occurrence.Subscriptions.Any(u => u.UserId.Equals(model.User.Id))).ToList();
foreach (var course in courses)
{
var summary = courseService.GetCourseSummary(course);
model.Courses.Add(summary);
var state = ActivityService.GetActivityState(course.Occurrence, user);
summary.User = user;
summary.Subscription = state.Subscription;
summary.Lottery =
Db.Lotteries.FirstOrDefault(x => x.Occurrences.Any(y => y.Id == course.Occurrence.Id));
}
return(View(model));
}
public ActionResult Responsibilities()
{
var organiser = GetMyOrganisation();
if (organiser == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var semester = SemesterService.GetSemester(DateTime.Today);
var model = new OrganiserViewModel
{
Organiser = organiser,
Semester = semester
};
model.Responsibilities = Db.MemberResponsibilities.Where(x => x.Member.Organiser.Id == organiser.Id).GroupBy(g => g.Tag).ToList();
// Benutzerrechte
ViewBag.UserRight = GetUserRight(User.Identity.Name, organiser.ShortName);
return(View(model));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
var organiser = GetMyOrganisation();
if (organiser == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var semester = SemesterService.GetSemester(DateTime.Today);
var nextSemester = SemesterService.GetNextSemester(semester);
var prevSemester = SemesterService.GetPreviousSemester(semester);
var model = new OrganiserViewModel
{
Organiser = organiser,
Semester = semester,
NextSemester = nextSemester,
PreviousSemester = prevSemester
};
// Benutzerrechte
ViewBag.UserRight = GetUserRight(User.Identity.Name, organiser.ShortName);
return(View(model));
}
// GET: Schedule
public ActionResult Index(Guid?semId)
{
var allPublishedSemester = Db.Semesters.Where(x => x.Groups.Any()).OrderByDescending(s => s.EndCourses).Take(4).ToList();
Semester semester = null;
if (semId != null)
{
semester = SemesterService.GetSemester(semId);
}
else
{
semester = Db.Semesters.Where(x => x.Groups.Any()).OrderByDescending(s => s.EndCourses).FirstOrDefault();
}
var isStaff = false;
var curricula = SemesterService.GetActiveCurricula(semester, !isStaff).ToList();
var model = new SemesterActiveViewModel
{
Semester = semester,
Curricula = curricula
};
ViewBag.AllSemester = allPublishedSemester;
return(View(model));
}
private DashboardStudentViewModel CreateDashboardModelStudentNew(UserRight userRight)
{
var student = StudentService.GetCurrentStudent(userRight.User.Id);
var currentSemester = student != null?SemesterService.GetNewestSemester(student.Curriculum.Organiser) : SemesterService.GetSemester(DateTime.Today);
var prevSemester = SemesterService.GetPreviousSemester(currentSemester);
var model = new DashboardStudentViewModel
{
User = userRight.User,
Semester = prevSemester,
NextSemester = currentSemester,
Student = student,
Organiser = student?.Curriculum.Organiser
};
if (student != null)
{
var limit = DateTime.Today.AddDays(-7);
model.Advertisements = Db.Advertisements.Where(x => x.Owner.Organiser.Id == student.Curriculum.Organiser.Id &&
x.Created >= limit).ToList();
}
else
{
model.Advertisements = new List <Advertisement>();
}
return(model);
}
public FormAdd()
{
InitializeComponent();
this.semesterService = new SemesterService();
this.studentsService = new StudentService();
this.LoadToComboBox();
}
public ActionResult Dictionary(Guid semId, Guid currId)
{
var semester = SemesterService.GetSemester(semId);
var curr = Db.Curricula.SingleOrDefault(x => x.Id == currId);
var courses = SemesterService.GetCourses(semester, curr);
var model = new SemesterScheduleViewModel
{
Semester = semester,
Curriculum = curr
};
foreach (var course in courses.OrderBy(x => x.Name))
{
var lectures =
Db.Members.Where(l => l.Dates.Any(occ => occ.Activity.Id == course.Id)).ToList();
var cModel = new CourseSummaryModel
{
Course = course,
Lecturers = lectures
};
model.Courses.Add(cModel);
}
return(View(model));
}
public PartialViewResult Faculty(Guid facultyId)
{
var newsletters = Db.Activities.OfType <Newsletter>().Where(x => x.Organiser.Id == facultyId).ToList();
var model = new List <NewsletterViewModel>();
var userRight = new UserRight();
userRight.User = UserManager.FindByName(User.Identity.Name);
userRight.Member = GetMyMembership();
var semester = SemesterService.GetSemester(DateTime.Today);
foreach (var newsletter in newsletters)
{
bool isMember = IsUserMemberOf(newsletter.Organiser.ShortName) || User.IsInRole("SysAdmin");
bool isAdmin = IsUserAdminOf(newsletter.Organiser.ShortName) || User.IsInRole("SysAdmin");
model.Add(new NewsletterViewModel
{
Newsletter = newsletter,
State = ActivityService.GetActivityState(newsletter.Occurrence, AppUser),
IsMember = isMember,
IsAdmin = isAdmin,
});
}
ViewBag.UserRight = userRight;
ViewBag.Curricula = Db.Curricula.ToList();
ViewBag.Semester = semester;
return(PartialView("_NewsletterList", model));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult Index(Guid id)
{
var curr = Db.Curricula.SingleOrDefault(x => x.Id == id);
var model = new CurriculumViewModel();
model.Curriculum = curr;
model.Semester = SemesterService.GetSemester(DateTime.Today);
var user = GetCurrentUser();
if (user.MemberState == MemberState.Staff)
{
model.ActiveSemesters.AddRange(Db.Semesters.Where(s =>
s.Groups.Any(g => g.CapacityGroup.CurriculumGroup.Curriculum.Id == curr.Id)));
}
else
{
model.ActiveSemesters.AddRange(Db.Semesters.Where(s =>
s.Groups.Any(g => g.CapacityGroup.CurriculumGroup.Curriculum.Id == curr.Id && g.IsAvailable)));
}
// hier muss überprüft werden, ob der aktuelle Benutzer
// der Fakultät des Studiengangs angehört oder nicht
ViewBag.UserRight = GetUserRight(model.Curriculum.Organiser);
return(View(model));
}
public PartialViewResult GroupList(string semId)
{
var semester = SemesterService.GetSemester(semId);
var org = GetMyOrganisation();
var model = new SemesterOverviewModel();
model.Semester = semester;
// hier jetzt das ganze zu Fuss
// var studentService = new StudentService(Db);
var groups = semester.Groups
.Where(g => g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == org.Id)
.OrderBy(g => g.CapacityGroup.CurriculumGroup.Curriculum.Name)
.ThenBy(g => g.CapacityGroup.CurriculumGroup.Name).ThenBy(g => g.CapacityGroup.Name).ToList();
foreach (var group in groups)
{
var groupModel = new SemesterGroupViewModel
{
Group = group,
//UserIds = studentService.GetStudents(group)
};
model.SemesterGroups.Add(groupModel);
}
return(PartialView("_StudentGroupSelect", model));
}
public ActionResult AllStudents(OccurrenceMailingModel model)
{
var logger = LogManager.GetLogger("AllStudentsMail");
if (ModelState.IsValid)
{
var semester = SemesterService.GetSemester(DateTime.Today);
var org = GetMyOrganisation();
/*
* var backgroundMailModel = GetMailModel(model);
* backgroundMailModel.OrgId = org.Id;
* backgroundMailModel.SemesterId = semester.Id;
* backgroundMailModel.SenderId = UserManager.FindByName(User.Identity.Name).Id;
* backgroundMailModel.IsImportant = model.IsImportant;
* backgroundMailModel.ListName = "Alle Studierende";
* backgroundMailModel.IsDistributionList = true;
*
* BackgroundJob.Enqueue<MailService>(x => x.SendAll(backgroundMailModel));
*/
// Alle Studierenden in Studiengängen des Veranstalters
ICollection <ApplicationUser> userList = new List <ApplicationUser>();
var allStudents = Db.Students.Where(x => x.Curriculum.Organiser.Id == org.Id);
var allUserIds = allStudents.Select(s => s.UserId).Distinct().ToList();
foreach (var userId in allUserIds)
{
ApplicationUser user = UserManager.FindById(userId);
if (user != null)
{
userList.Add(user);
}
}
model.ListName = "Alle Studierende";
model.IsDistributionList = true;
logger.InfoFormat("UserList with {0} entires", userList.Count);
// Der SysAdmin kann nicht versenden - es wird nur geloggt!
if (!User.IsInRole("SysAdmin"))
{
SendMail(userList, model);
}
//ICollection<ApplicationUser> userList = new List<ApplicationUser>();
return(View("ReceiverList", userList));
}
else
{
return(View());
}
}