/// <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));
}
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 Index()
{
// Alle Semester mit Stundenplänen, die in der Zukunft enden
var semesterList = Db.Semesters.Where(x =>
x.EndCourses >= DateTime.Today &&
x.Groups.Any(g => g.IsAvailable)).ToList();
var semSubService = new SemesterSubscriptionService(Db);
var model = new List <SemesterSubscriptionOverviewModel>();
foreach (var semester in semesterList)
{
var semGroup = semSubService.GetSemesterGroup(AppUser.Id, semester);
var m = new SemesterSubscriptionOverviewModel
{
Semester = semester,
Group = semGroup
};
model.Add(m);
}
return(View(model));
}
public PartialViewResult Search(string searchString)
{
var semester = SemesterService.GetSemester(DateTime.Today);
var model = new List <StudentViewModel>();
if (!string.IsNullOrEmpty(searchString))
{
var userDb = new ApplicationDbContext();
var users = from s in userDb.Users select s;
if (!string.IsNullOrEmpty(searchString))
{
users = users.Where(u =>
u.MemberState == MemberState.Student &&
(u.FirstName.ToUpper().Contains(searchString.ToUpper()) ||
u.LastName.ToUpper().Contains(searchString.ToUpper()))
);
}
var semSubService = new SemesterSubscriptionService();
foreach (var user in users)
{
var studModel = new StudentViewModel
{
User = user,
Student = Db.Students.Where(x => x.UserId.Equals(user.Id)).OrderByDescending(x => x.Created).FirstOrDefault()
};
// alle Kurse des Benutzers
var courses =
Db.Activities.OfType <Course>()
.Where(c => c.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id)) &&
c.SemesterGroups.Any((g => g.Semester.Id == semester.Id)))
.OrderBy(c => c.Name)
.ToList();
studModel.CurrentCourses = courses;
model.Add(studModel);
}
}
model = model.OrderBy(u => u.User.LastName).ToList();
ViewBag.CurrentSemester = semester;
return(PartialView("_Profile", model));
}
public ActionResult Change()
{
var semester = SemesterService.GetSemester(DateTime.Today);
var user = GetCurrentUser();
var semSubService = new SemesterSubscriptionService();
var semesterSubscription = semSubService.GetSemesterGroup(user.Id, semester);
var model = new CurriculumSubscriptionViewModel
{
OrgId = semesterSubscription?.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id ?? Guid.Empty,
CurrId = semesterSubscription?.CapacityGroup.CurriculumGroup.Curriculum.Id ?? Guid.Empty,
SemId = semester.Id
};
var orgs = Db.Organisers.Where(x => x.IsFaculty && x.Curricula.Any()).OrderBy(f => f.ShortName).ToList();
var org = semesterSubscription?.CapacityGroup.CurriculumGroup.Curriculum.Organiser ?? orgs.FirstOrDefault();
ViewBag.Faculties = orgs.Select(f => new SelectListItem
{
Text = f.ShortName,
Value = f.Id.ToString(),
});
ViewBag.Curricula = org.Curricula.OrderBy(f => f.ShortName).Select(f => new SelectListItem
{
Text = f.Name,
Value = f.Id.ToString(),
});
var nextDate = DateTime.Today.AddDays(70);
ViewBag.Semesters = Db.Semesters.Where(x => x.StartCourses <= nextDate).OrderByDescending(x => x.EndCourses)
.Select(f => new SelectListItem
{
Text = f.Name,
Value = f.Id.ToString(),
}
);
return(View(model));
}
public ActionResult UpdateSemesterGroup(SemesterSubscriptionViewModel model)
{
var user = AppUser;
var semSubService = new SemesterSubscriptionService();
if (user != null)
{
var group = Db.SemesterGroups.SingleOrDefault(g => g.Id.ToString().Equals(model.CurrGroup));
if (group != null)
{
semSubService.Subscribe(user.Id, group.Id);
model.Group = group;
}
}
return(RedirectToAction("Index"));
}
public ActionResult Schedule(Guid id)
{
var userRight = GetUserRight();
ViewBag.UserRight = userRight;
var semSubService = new SemesterSubscriptionService();
var user = AppUser;
// das übergebene Semester
var currentSemester = SemesterService.GetSemester(id);
var model = new DashboardStudentViewModel();
model.User = user;
model.Organiser = GetMyOrganisation();
model.Semester = currentSemester;
model.SemesterGroup = semSubService.GetSemesterGroup(user.Id, currentSemester);
return(View(model));
}
public ActionResult Issue(Guid id)
{
var subscription = Db.Subscriptions.OfType <OccurrenceSubscription>().SingleOrDefault(x => x.Id == id);
var supervision = Db.Activities.OfType <Supervision>()
.SingleOrDefault(x => x.Occurrence.Id == subscription.Occurrence.Id);
var user = GetUser(subscription.UserId);
var subInfoService = new SemesterSubscriptionService();
var semester = SemesterService.GetSemester(DateTime.Today);
var model = new ThesisAcceptModel
{
Subscription = subscription,
Supervision = supervision,
User = user
};
model.Curriculum = subInfoService.GetBestCurriculum(subscription.UserId, semester);
model.Lecturer = supervision.Owners.First().Member;
int period = 0;
bool success = int.TryParse(model.Curriculum.Version, out period);
if (!success || period == 0)
{
period = 3;
}
model.Period = period;
model.IssueDate = DateTime.Today;
model.DeliveryDate = model.IssueDate.AddMonths(period);
return(View(model));
}
private DashboardStudentViewModel CreateDashboardModelStudent(UserRight userRight)
{
var semSubService = new SemesterSubscriptionService();
var currentSemester = SemesterService.GetSemester(DateTime.Today);
var nextSemester = SemesterService.GetNextSemester(DateTime.Today);
var model = new DashboardStudentViewModel
{
User = userRight.User,
Semester = currentSemester,
SemesterGroup = semSubService.GetSemesterGroup(userRight.User.Id, currentSemester),
Student = Db.Students.Where(x => x.UserId.Equals(userRight.User.Id)).OrderByDescending(x => x.Created).FirstOrDefault()
};
// keine Semestergruppe gewählt => aktive Pläne suchen
if (model.SemesterGroup == null)
{
model.ActiveOrgsSemester = SemesterService.GetActiveOrganiser(currentSemester, true);
}
// das nächste Semester nur anzeigen, wenn es einen veröffentlichsten Stundenplan für die letzte Fakultät gibt!
var nextSemesterOrgs = SemesterService.GetActiveOrganiser(nextSemester, true);
if (nextSemesterOrgs.Any())
{
model.NextSemester = nextSemester;
model.NextSemesterGroup = semSubService.GetSemesterGroup(userRight.User.Id, nextSemester);
if (model.NextSemesterGroup == null)
{
model.ActiveOrgsNextSemester = nextSemesterOrgs;
}
}
// Alle Anfragen zu Abschlussarbeiten
var supervisions = Db.Activities.OfType <Supervision>()
.Where(x => x.Occurrence.Subscriptions.Any(y => y.UserId.Equals(userRight.User.Id))).ToList();
foreach (var supervision in supervisions)
{
var request = new SupervisionRequestModel();
request.Supervision = supervision;
request.Lecturer = supervision.Owners.First().Member;
request.Subscription =
supervision.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(userRight.User.Id));
model.Requests.Add(request);
}
// Alle Abschlussarbeiten
var theses = Db.Theses.Where(x => x.Student.UserId.Equals(userRight.User.Id)).ToList();
foreach (var thesis in theses)
{
var tModel = new ThesisDetailModel();
tModel.Thesis = thesis;
tModel.Lecturer = thesis.Supervision.Owners.First().Member;
model.Theses.Add(tModel);
}
// Alle heutigen Termine
// Alle Eintragungen
var begin = DateTime.Now;
var end = DateTime.Today.AddDays(1);
var allDates =
Db.ActivityDates.Where(d =>
(d.Activity.Occurrence.Subscriptions.Any(s => s.UserId.Equals(userRight.User.Id)) ||
d.Occurrence.Subscriptions.Any(s => s.UserId.Equals(userRight.User.Id)) ||
d.Slots.Any(slot => slot.Occurrence.Subscriptions.Any(s => s.UserId.Equals(userRight.User.Id)))) &&
d.End >= begin && d.End <= end).OrderBy(d => d.Begin).ToList();
foreach (var date in allDates)
{
var act = new AgendaActivityViewModel
{
Date = date,
Slot = date.Slots.FirstOrDefault(x => x.Occurrence.Subscriptions.Any(s => s.UserId.Equals(userRight.User.Id)))
};
model.TodaysActivities.Add(act);
}
if (model.Student != null)
{
var org = model.Student.Curriculum.Organiser;
// Alle Platzverlosungen
// letzte 90 Tage
var lastEnd = DateTime.Today;
var alLotteries = Db.Lotteries.Where(x =>
x.IsActiveUntil >= lastEnd && x.IsAvailable &&
x.Organiser != null && x.Organiser.Id == org.Id).OrderBy(x => x.FirstDrawing).ToList();
foreach (var lottery in alLotteries)
{
var courseList = new List <Course>();
courseList.AddRange(
lottery.Occurrences.Select(
occurrence => Db.Activities.OfType <Course>().SingleOrDefault(
c => c.Occurrence.Id == occurrence.Id)).Where(course => course != null));
var hasFit =
courseList.Any(c => c.SemesterGroups.Any(g =>
g.CapacityGroup.CurriculumGroup.Curriculum.Id == model.Student.Curriculum.Id));
if (hasFit)
{
model.Lotteries.Add(lottery);
}
}
}
return(model);
}
public ActionResult SendInvitations(OccurrenceMailingModel model)
{
var host = AppUser;
var invitationList = Session["InvitationList"] as InvitationCheckModel;
var semSubService = new SemesterSubscriptionService();
// Keine Liste
// Vermutung, die Session ist abgelaufen
if (invitationList == null)
{
return(View("SendInvitationsError"));
}
var attachmentList = new List <CustomMailAttachtmentModel>();
foreach (var attachment in model.Attachments)
{
if (attachment != null)
{
var bytes = new byte[attachment.ContentLength];
attachment.InputStream.Read(bytes, 0, attachment.ContentLength);
attachmentList.Add(new CustomMailAttachtmentModel
{
FileName = Path.GetFileName(attachment.FileName),
Bytes = bytes,
});
}
}
foreach (var invitation in invitationList.Invitations.Where(i => i.Invite))
{
invitation.Invited = false;
var now = DateTime.Now;
var user = new ApplicationUser
{
UserName = invitation.Email,
Email = invitation.Email,
FirstName = invitation.FirstName,
LastName = invitation.LastName,
Registered = now,
MemberState = MemberState.Student,
Remark = "Einladung von " + host.FullName,
ExpiryDate = null, // Einladung bleibt dauerhaft bestehen - Deprovisionierung automatisch
Submitted = now,
EmailConfirmed = true, // damit ist auch ein "ForgotPassword" möglich, auch wenn er die Einladung nicht angenommen hat.
IsApproved = true, // Damit bekommt der Nutzer von Anfang an E-Mails
Faculty = host.Id // Benutzer der eingeladen hat
};
// Benutzer anlegen, mit Dummy Passwort
//string pswd = Membership.GeneratePassword(10, 2);
var result = UserManager.Create(user, "Pas1234?");
if (result.Succeeded)
{
// analog Forget E-Mail Versand
string code = UserManager.GeneratePasswordResetToken(user.Id);
var mailModel = new ForgotPasswordMailModel
{
User = user,
Token = code,
CustomSubject = model.Subject,
CustomBody = model.Body,
Attachments = attachmentList,
IsNewAccount = true,
};
try
{
new MailController().InvitationMail(mailModel, host, model.TemplateLanguage).Deliver();
// Student anlegen
var student = Db.Students.FirstOrDefault(x => x.UserId.Equals(user.Id));
if (student == null)
{
var sem = SemesterService.GetSemester(invitation.Semester);
var org = Db.Organisers.SingleOrDefault(x =>
x.ShortName.Equals(invitation.Organiser));
var curr = org.Curricula.SingleOrDefault(c => c.ShortName.Equals(invitation.Curriculum));
student = new Student
{
Created = DateTime.Now,
Curriculum = curr,
FirstSemester = sem,
UserId = user.Id
};
Db.Students.Add(student);
Db.SaveChanges();
}
//semSubService.Subscribe(user.Id, invitation.SemGroup.Id);
invitation.Invited = true;
}
catch (SmtpFailedRecipientException ex)
{
invitation.Remark = ex.Message;
}
}
else
{
foreach (var error in result.Errors)
{
invitation.Remark += error;
}
}
}
var deliveryMailModel = new GenericMailDeliveryModel
{
Subject = model.Subject,
Receiver = host,
TemplateContent = new UserMailModel
{
CustomBody = model.Body,
}
};
// Mail an Einladenden versenden
var ms = new MemoryStream();
var writer = new StreamWriter(ms, Encoding.Default);
writer.Write(
"Name;Vorname;E-Mail;Versand;Bemerkung");
writer.Write(Environment.NewLine);
foreach (var delivery in invitationList.Invitations)
{
writer.Write("{0};{1};{2};{3};{4}",
delivery.LastName, delivery.FirstName, delivery.Email,
(delivery.Invite && delivery.Invited) ? "OK" : "FEHLER",
delivery.Remark);
writer.Write(Environment.NewLine);
}
writer.Flush();
writer.Dispose();
var sb = new StringBuilder();
sb.Append("Versandbericht");
sb.Append(".csv");
deliveryMailModel.Attachments.Add(new CustomMailAttachtmentModel
{
FileName = sb.ToString(),
Bytes = ms.GetBuffer()
});
try
{
new MailController().GenericMail(deliveryMailModel).Deliver();
}
catch (Exception ex)
{
var logger = LogManager.GetLogger("SendMail");
logger.ErrorFormat("Mailsent failed: {0}", ex.Message);
}
return(View("SendInvitationsSuccess", invitationList));
}
private SemesterSubscriptionViewModel GetModel(Semester semester)
{
var model = new SemesterSubscriptionViewModel
{
Semester = semester.Id.ToString(),
Group = null,
Faculty = string.Empty,
Curriculum = string.Empty,
CurrGroup = string.Empty,
};
var semService = new SemesterService(Db);
var semSubService = new SemesterSubscriptionService(Db);
// Alle Fakultäten, die aktive Semestergruppen haben
var acticeorgs = semService.GetActiveOrganiser(semester, true);
ViewBag.Semesters = new List <SelectListItem>()
{
new SelectListItem
{
Text = semester.Name,
Value = semester.Id.ToString()
}
};
// Immer alle anzeigen, die was haben
ViewBag.Faculties = acticeorgs.OrderBy(f => f.ShortName).Select(f => new SelectListItem
{
Text = f.ShortName,
Value = f.Id.ToString(),
});
// Liste der Studiengänge
var actOrg = acticeorgs.FirstOrDefault();
var activecurr = semService.GetActiveCurricula(actOrg, semester, true);
// Liste der Gruppen hängt jetzt von der Einschreibung ab
// keine Einschreibung vorhanden
if (!activecurr.Any())
{
model.HasData = false;
}
else
{
model.HasData = true;
ViewBag.Curricula = activecurr.OrderBy(f => f.ShortName).Select(f => new SelectListItem
{
Text = string.Format("{0} ({1})", f.ShortName, f.Name),
Value = f.Id.ToString(),
});
// nimm den ersten
var myCurr = activecurr.First();
var semesterGroups = Db.SemesterGroups.Where(g =>
g.Semester.Id == semester.Id &&
g.IsAvailable &&
g.CapacityGroup.CurriculumGroup.Curriculum.Id == myCurr.Id).OrderBy(g => g.CapacityGroup.CurriculumGroup.Name).ToList();
var semGroups = semesterGroups.Select(s => new SelectListItem
{
Text = s.FullName,
Value = s.Id.ToString()
}).ToList();
ViewBag.Groups = semGroups;
}
ViewBag.Semester = semester;
return(model);
}
public PartialViewResult ListByGroup(Guid semGroupId)
{
var semGroup = Db.SemesterGroups.SingleOrDefault(g => g.Id == semGroupId);
var semester = SemesterService.GetSemester(DateTime.Today);
var vorSemester = SemesterService.GetPreviousSemester(semester);
var model = new List <StudentViewModel>();
if (semGroup != null)
{
var semSubService = new SemesterSubscriptionService();
foreach (var sub in semGroup.Subscriptions)
{
var user = UserManager.FindById(sub.UserId);
if (user != null)
{
var studModel = new StudentViewModel
{
User = user,
CurrentSubscription = semSubService.GetSubscription(user.Id, semester.Id),
LastSubscription = semSubService.GetSubscription(user.Id, vorSemester.Id)
};
// alle Kurse des Benutzers
var courses =
Db.Activities.OfType <Course>()
.Where(c => c.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id)) &&
c.SemesterGroups.Any((g => g.Semester.Id == semester.Id)))
.OrderBy(c => c.Name)
.ToList();
studModel.AllCourses = courses;
var coursesFit =
Db.Activities.OfType <Course>()
.Where(c => c.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id)) &&
c.SemesterGroups.Any((g => g.Id == semGroupId)))
.OrderBy(c => c.Name)
.ToList();
studModel.CoursesFit = coursesFit;
model.Add(studModel);
}
}
}
model = model.OrderBy(u => u.User.LastName).ToList();
ViewBag.CurrentSemester = semester;
ViewBag.LastSemester = vorSemester;
return(PartialView("Persons", model));
}
public PartialViewResult Persons(string searchString)
{
var semester = SemesterService.GetSemester(DateTime.Today);
var vorSemester = new SemesterService().GetSemester(semester, 1);
var model = new List <StudentViewModel>();
if (!string.IsNullOrEmpty(searchString))
{
var userDb = new ApplicationDbContext();
var users = from s in userDb.Users select s;
if (!string.IsNullOrEmpty(searchString))
{
users = users.Where(u =>
u.MemberState == MemberState.Student &&
(u.FirstName.ToUpper().Contains(searchString.ToUpper()) ||
u.LastName.ToUpper().Contains(searchString.ToUpper()))
);
}
var semSubService = new SemesterSubscriptionService();
foreach (var user in users)
{
var studModel = new StudentViewModel
{
User = user,
CurrentSubscription = semSubService.GetSubscription(user.Id, semester.Id),
LastSubscription = semSubService.GetSubscription(user.Id, vorSemester.Id)
};
var semesterSubscription = Db.Subscriptions.OfType <SemesterSubscription>()
.FirstOrDefault(s => s.SemesterGroup.Semester.Id == semester.Id && s.UserId.Equals(user.Id));
// alle Kurse des Benutzers
var courses =
Db.Activities.OfType <Course>()
.Where(c => c.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id)) &&
c.SemesterGroups.Any((g => g.Semester.Id == semester.Id)))
.OrderBy(c => c.Name)
.ToList();
studModel.AllCourses = courses;
var coursesFit = new List <Course>();
if (semesterSubscription != null)
{
coursesFit = Db.Activities.OfType <Course>()
.Where(
c =>
c.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id)) &&
c.SemesterGroups.Any((g => g.Id == semesterSubscription.SemesterGroup.Id)))
.OrderBy(c => c.Name)
.ToList();
}
studModel.CoursesFit = coursesFit;
model.Add(studModel);
}
}
model = model.OrderBy(u => u.User.LastName).ToList();
ViewBag.CurrentSemester = semester;
ViewBag.LastSemester = vorSemester;
return(PartialView("Persons", model));
}
