public static MvcHtmlString SubscriptionLabel(this HtmlHelper htmlHelper, OccurrenceSubscription subscription)
{
var sb = new StringBuilder();
var iconName = "";
if (subscription.OnWaitingList)
{
iconName = "fa-hourglass";
}
else
{
if (subscription.IsConfirmed)
{
iconName = "fa-group";
}
else
{
iconName = "fa-ticket";
}
}
sb.AppendFormat(
"<i class=\"fa {0}\"></i>", iconName);
return(new MvcHtmlString(sb.ToString()));
}
public BookingTicket Subscribe(string userId, Guid courseId)
{
var ticket = new BookingTicket();
var course = Db.Activities.OfType <Course>().SingleOrDefault(x => x.Id == courseId);
var student = GetStudent(userId);
ticket.Course = course;
ticket.UserId = userId;
var occurrence = course.Occurrence;
OccurrenceSubscription subscription = null;
using (var transaction = Db.Database.BeginTransaction())
{
subscription = occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(userId));
var bookingLists = GetBookingLists(occurrence.Id);
var bookingState = new BookingState();
bookingState.Student = student;
bookingState.Occurrence = occurrence;
bookingState.BookingLists = bookingLists;
bookingState.Init();
var myBookingList = bookingState.MyBookingList;
if (subscription != null)
{
DeleteSubscription(subscription);
if (myBookingList != null && !subscription.OnWaitingList)
{
var succeedingBooking = myBookingList.GetSucceedingBooking();
if (succeedingBooking != null)
{
succeedingBooking.Subscription.OnWaitingList = false;
ticket.SucceedingSubscription = succeedingBooking.Subscription;
}
}
}
else
{
if (myBookingList != null)
{
subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.Occurrence = occurrence;
subscription.UserId = userId;
subscription.OnWaitingList = bookingState.AvailableSeats <= 0;
Db.Subscriptions.Add(subscription);
ticket.Subscription = subscription;
}
}
Db.SaveChanges();
transaction.Commit();
}
return(ticket);
}
private void AddMessage(Course course, OccurrenceSubscription subscription, string remark)
{
Messages.Add(new DrawingMessage
{
TimeStamp = DateTime.Now,
Course = course,
Subscription = subscription,
UserId = subscription?.UserId,
Remark = remark
});
}
public ActionResult CreateRequest(SupervisionRequestModel model)
{
var user = GetCurrentUser();
var supervision = Db.Activities.OfType <Supervision>().SingleOrDefault(x => x.Id == model.Supervision.Id);
// hat schon eine Anfrage bei diesem Angebot
if (supervision.Occurrence.Subscriptions.Any(x => x.UserId.Equals(user.Id)))
{
// Schon eingetragen
// Fehlermeldung: da sind sie schon drin
return(RedirectToAction("Index", "Dashboard"));
}
// Lehrende sollten sehen können, wo jemand eingetragen ist
// Die Ablehnungs Mails sind dann Nachweis für ein "Nichtfinden"
var subscription = new OccurrenceSubscription
{
UserId = user.Id,
SubscriberRemark = model.Description,
TimeStamp = DateTime.Now,
OnWaitingList = true,
IsConfirmed = false,
Occurrence = supervision.Occurrence
};
Db.Subscriptions.Add(subscription);
Db.SaveChanges();
// EMail versenden
// Mail an Betreuer
if (supervision.Owners.Any())
{
var member = supervision.Owners.First().Member;
var hostUser = GetUser(member.UserId);
var mailModel = new ThesisRequestMailModel
{
Supervision = supervision,
Request = subscription,
Requester = user, // der anfragende Student
User = hostUser, // der Betreuuer
};
var mail = new MailController();
mail.ThesisRequestEMail(mailModel).Deliver();
}
return(RedirectToAction("Index", "Dashboard"));
}
public int GetPosition(OccurrenceSubscription subscription)
{
var orderedWaiting = WaitingList.OrderBy(x => x.Subscription.TimeStamp).ToList();
var booking = orderedWaiting.FirstOrDefault(x => x.Subscription.Id == subscription.Id);
if (booking != null)
{
return(orderedWaiting.IndexOf(booking) + 1);
}
return(-1);
}
private OccurrenceSubscription AddOnWaitingList(Occurrence occurrence, ApplicationUser user)
{
var subscription = new OccurrenceSubscription
{
UserId = user.Id,
TimeStamp = DateTime.Now,
OnWaitingList = true,
IsConfirmed = false
};
occurrence.Subscriptions.Add(subscription);
Db.SaveChanges();
return(subscription);
}
public void DeleteSubscription(OccurrenceSubscription subscription)
{
var allDrawings = Db.SubscriptionDrawings.Where(x => x.Subscription.Id == subscription.Id).ToList();
foreach (var drawing in allDrawings)
{
Db.SubscriptionDrawings.Remove(drawing);
}
var bets = subscription.Bets.ToList();
foreach (var bet in bets)
{
Db.LotteriyBets.Remove(bet);
}
Db.Subscriptions.Remove(subscription);
Db.SaveChanges();
}
public void SendSucceedingEMail(Course course, OccurrenceSubscription subscription)
{
var email = new SubscriptionEmail("Succeeding")
{
Subject = "[nine] Eintragung in " + course.Name,
Course = course,
Subscription = subscription,
Student = UserService.GetUser(subscription.UserId)
};
try
{
EmailService.Send(email);
Logger.InfoFormat("E-Mail an {0} erfolgreich versendet", email.Student.Email);
}
catch (Exception exMail)
{
Logger.ErrorFormat("Fehler bei E-Mail Versand an: {0} - Ursache {1}", email.Student.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);
}
}
public IQueryable <SubscriptionDto> Subscribe([FromBody] SubscriptionBasketModel model)
{
var list = new List <SubscriptionDto>();
var user = GetUser(model.User.Id);
if (user == null)
{
var subModel = new SubscriptionDto
{
CourseId = Guid.Empty,
IsValid = false,
Message = $"Invaild user with id {model.User.Id}"
};
list.Add(subModel);
return(list.AsQueryable());
}
foreach (var courseModel in model.Courses)
{
var subModel = new SubscriptionDto();
subModel.CourseId = courseModel.Id;
subModel.IsValid = true;
var course = Db.Activities.OfType <Course>().SingleOrDefault(x => x.Id == courseModel.Id);
if (course != null)
{
var subscription = course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(model.User.Id));
if (subscription == null)
{
subscription = new OccurrenceSubscription();
subscription.UserId = model.User.Id;
subscription.TimeStamp = DateTime.Now;
subscription.Occurrence = course.Occurrence;
// TODO: Status "Warteliste" dafür dann den Service bauen
// einfach: wenn LV zu CIE gehört, dann Warteliste
bool isCie = course.SemesterGroups.Any(x =>
x.CapacityGroup.CurriculumGroup.Curriculum.ShortName.StartsWith("CIE"));
if (isCie)
{
subscription.OnWaitingList = true;
}
subscription.SubscriberRemark = "Über API eingeschrieben";
subscription.Priority = 1;
Db.Subscriptions.Add(subscription);
}
}
else
{
subModel.IsValid = false;
subModel.Message = $"Inavlid Course with Id {courseModel.Id}";
}
list.Add(subModel);
}
Db.SaveChanges();
return(list.AsQueryable());
}
/// <summary>
///
/// </summary>
/// <param name="date"></param>
/// <param name="dateType"></param>
public ActivityDateSummary(ActivityDate date, OccurrenceSubscription sub)
{
Date = date;
DateType = ActivityDateType.Subscription;
Subscription = sub;
}
/// <summary>
///
/// </summary>
/// <param name="occId"></param>
/// <param name="user"></param>
/// <returns></returns>
public SubscriptionResponse SubscribeOccurrence(Guid occId, ApplicationUser user)
{
var occurrence = Db.Occurrences.SingleOrDefault(ac => ac.Id == occId);
if (occurrence == null || user == null)
{
return(GetErrorResponse("Missing Or Wrong Occurrence Or Missing User", false));
}
// Nach einer bestehenden Eintragung suchen
// sollte aus irgendeinem Grund bereits mehrere Eintragungen bestehen, dann ist das hier nicht von Interesse
// es genügt die Information, dass bereits eine Eintragung existiert
OccurrenceSubscription subscription = occurrence.Subscriptions.FirstOrDefault(s => s.UserId.Equals(user.Id));
if (subscription != null)
{
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
#region Zeitraum prüfen
var timingState = GetSubscriptionState(occurrence);
if (timingState == SubscriptionState.BeforeSubscriptionPhase)
{
return(new SubscriptionResponse
{
HasError = true,
ShowUser = true,
Message = string.Format("Noch zu früh! Eintragung erst ab {0} möglich", occurrence.FromDateTime.Value),
});
}
if (timingState == SubscriptionState.AfterSubscriptionPhase ||
timingState == SubscriptionState.DuringOccurrence ||
timingState == SubscriptionState.AfterOccurrence)
{
return(new SubscriptionResponse
{
HasError = true,
ShowUser = true,
Message = "Zu spät! Keine Eintragung mehr möglich!",
});
}
#endregion
#region Alles auf Warteliste: Inaktiv gesetzt oder Platzverlosung
var hasLottery = Db.Lotteries.Any(x => x.Occurrences.Any(y => y.Id == occurrence.Id));
if (occurrence.IsAvailable == false || hasLottery)
{
subscription = AddOnWaitingList(occurrence, user);
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
#endregion
#region Gruppen berücksichtigen
if (occurrence.UseGroups)
{
var semSubService = new SemesterSubscriptionService();
// die beste Gruppe ermitteln => die erste, die passt
var group = semSubService.GetBestFit(user.Id, occurrence.Groups);
// Wenn der Benutzer nicht zur erforderlichen Gruppe gehört
// dan automatisch auf der Warteliste positionieren
if (group == null)
{
subscription = AddOnWaitingList(occurrence, user);
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
// als nächstes die Anzahl der Teilnehmer in dieser Gruppe ermitteln
var participants = GetSubscriptionsForGroup(occurrence.Subscriptions, group);
// Es ist noch Platz in der Gruppe
if (participants.Count < group.Capacity)
{
subscription = AddOnParticipantList(occurrence, user);
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
// Alle Plätze in der Gruppe sind belegt
// auf die Warteliste
subscription = AddOnWaitingList(occurrence, user);
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
else
{
// keine Gruppen berücksichtigen
// und es interessiert hier nicht die Annahme des Platzes!
var nParticipants = occurrence.Subscriptions.Count(s => s.OnWaitingList == false);
if (occurrence.Capacity < 0 || nParticipants < occurrence.Capacity)
{
subscription = AddOnParticipantList(occurrence, user);
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
// Auf Warteliste setzen
// Spezialfälle
// Bei einem Slot oder Datum (Sprechstunde) gibt es keine Wartelisten
var summary = new ActivityService().GetSummary(occurrence.Id);
if (summary is ActivitySlotSummary || summary is ActivityDateSummary)
{
return(new SubscriptionResponse
{
HasError = true,
ShowUser = true,
Message = "Leider bereits belegt",
});
}
else
{
subscription = AddOnWaitingList(occurrence, user);
return(new SubscriptionResponse
{
HasError = false,
Subscription = subscription
});
}
}
#endregion
}
private int TryToFillUp()
{
var nSuccess = 0;
foreach (var game in Games)
{
var studentLots = game.Lots.OrderBy(x => x.Priority).ToList();
// Hat Student alle Wünsche erfüllt bekommen
var isJinx = (studentLots.Count(x => !x.Subscription.OnWaitingList) + game.Seats.Count) < game.CoursesWanted;
if (isJinx)
{
// Suche einen Kurs, der noch freie Plätze hat und in dem er noch nicht drin ist
var availableCourse = LotPots.Where(x =>
!x.Course.Occurrence.Subscriptions.Any(s => s.UserId.Equals(game.UserId)) &&
x.SeatsAvailable > 0).OrderByDescending(x => x.SeatsAvailable).FirstOrDefault();
if (availableCourse == null)
{
game.Message = "Im gesamten Wahlverfahren stehen keine freien Plätze mehr zur Verfügung.";
}
else
{
if (game.AcceptDefault)
{
// eine neue Eintragung
var subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.UserId = game.UserId;
subscription.OnWaitingList = false;
subscription.Priority = 0;
subscription.Occurrence = availableCourse.Course.Occurrence;
// Die Subscription hinzufügen
availableCourse.Course.Occurrence.Subscriptions.Add(subscription);
// Die Bookinglist aktualisieren
availableCourse.BookingList.Bookings.Add(new Booking.Data.Booking
{
Student = game.Student,
Subscription = subscription
});
// Ein neues Los
var lot = new DrawingLot();
lot.IsTouched = true;
lot.IsValid = true;
lot.AddMessage("Platz durch Auffüllen erhalten");
lot.Subscription = subscription;
lot.Course = availableCourse.Course;
game.Lots.Add(lot);
availableCourse.Lots.Add(lot);
/*
* var lotPot = LotPots.SingleOrDefault(x => x.Course.Id == availableCourse.Course.Id);
* lotPot.Lots.Add(lot);
*/
AddMessage(lot.Course, lot.Subscription, "Platz durch Auffüllen erhalten");
nSuccess++;
}
else
{
AddMessage(game.UserId, "Will nichts anderes. Es hätte noch einen Platz in einer anderen Lehrveranstaltung gegeben.");
game.Message =
"Es hätte noch einen Platz in einer anderen Lehrveranstaltung gegeben.";
}
}
}
}
return(nSuccess);
}
private void TryToHelpJinx()
{
foreach (var game in Games)
{
var studentLots = game.Lots.OrderBy(x => x.Priority).ToList();
// Student ist Ober-Pechvogel, wenn er gar nichts erhalten hat => zuerst 1 Kurs
// gar nichts: Keinen Platz und auch kein Los auf der Warteliste
// alte Formulierung
// var isJinx = !game.Seats.Any() && studentLots.All(x => x.IsValid && x.Subscription.OnWaitingList);
var nSeats = game.Seats.Count;
var nLots = studentLots.Count;
var nWaitingLots = studentLots.Count(x => x.Subscription.OnWaitingList);
var validLots = studentLots.Count(x => x.IsValid);
var nWaitingValidLots = studentLots.Count(x => x.IsValid && x.Subscription.OnWaitingList);
AddMessage(game.UserId, $"Plätze: {nSeats}, Lose {nLots}, auf Warteliste {nWaitingLots}, valide {validLots}, valide und Warteliste {nWaitingValidLots}");
bool isJinx = nSeats == 0 && nLots == nWaitingLots;
if (isJinx)
{
AddMessage(game.UserId, $"Bisher keinen Platz erhalten");
// Suche einen Kurs, der noch freie Plätze hat und in dem er noch nicht drin ist
var availableCourses = LotPots.Where(x =>
!x.Course.Occurrence.Subscriptions.Any(s => s.UserId.Equals(game.UserId)) &&
x.SeatsAvailable > 0).OrderByDescending(x => x.SeatsAvailable).ToList();
AddMessage(null, null, $"Es sind {availableCourses.Count} LVs noch frei");
var availableCourse = availableCourses.FirstOrDefault();
if (availableCourse == null)
{
game.Message = "Im gesamten Wahlverfahren stehen keine freien Plätze mehr zur Verfügung.";
}
else
{
if (game.AcceptDefault)
{
// eine neue Eintragung
var subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.UserId = game.UserId;
subscription.OnWaitingList = false;
subscription.Priority = 0;
subscription.Occurrence = availableCourse.Course.Occurrence;
// Die Subscription hinzufügen
availableCourse.Course.Occurrence.Subscriptions.Add(subscription);
// Die Bookinglist aktualisieren
availableCourse.BookingList.Bookings.Add(new Booking.Data.Booking
{
Student = game.Student,
Subscription = subscription
});
var lot = new DrawingLot();
lot.IsTouched = true;
lot.IsValid = true;
lot.AddMessage("Platz über Pechvogelregel erhaltem");
lot.Subscription = subscription;
lot.Course = availableCourse.Course;
game.Lots.Add(lot);
availableCourse.Lots.Add(lot);
AddMessage(lot.Course, lot.Subscription, "Platz über Pechvogelregel erhaltem");
/*
* var lotPot = LotPots.SingleOrDefault(x => x.Course.Id == availableCourse.Course.Id);
* lotPot.Lots.Add(lot);
*/
}
else
{
AddMessage(game.UserId, "Will nichts anderes. Es hätte noch einen Platz in einer anderen Lehrveranstaltung gegeben.");
game.Message =
"Es hätte noch einen Platz in einer anderen Lehrveranstaltung gegeben.";
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="id">Id des Kurses</param>
/// <returns></returns>
public PartialViewResult Subscribe(Guid id)
{
var logger = LogManager.GetLogger("Booking");
var user = GetCurrentUser();
var student = StudentService.GetCurrentStudent(user);
var course = Db.Activities.OfType <Course>().SingleOrDefault(x => x.Id == id);
OccurrenceSubscription succeedingSubscription = null;
Occurrence occ = course.Occurrence;
OccurrenceSubscription subscription = null;
using (var transaction = Db.Database.BeginTransaction())
{
subscription = occ.Subscriptions.FirstOrDefault(x => x.UserId.Equals(user.Id));
var bookingService = new BookingService(Db);
var bookingLists = bookingService.GetBookingLists(occ.Id);
var bookingState = new BookingState
{
Student = student,
Occurrence = occ,
BookingLists = bookingLists
};
bookingState.Init();
var bookingList = bookingState.MyBookingList;
if (subscription == null)
{
// eintragen
// den Status aus den Buchungslisten ermitteln
// ermittle Buchungsliste
// wenn eine Liste
// wenn voll, dann Warteliste
// sonst Teilnehmer
// sonst
// Fehlermeldung an Benutzer mit Angabe des Grunds
if (bookingList != null)
{
subscription = new OccurrenceSubscription
{
TimeStamp = DateTime.Now,
Occurrence = occ,
UserId = user.Id,
OnWaitingList = bookingState.AvailableSeats <= 0
};
Db.Subscriptions.Add(subscription);
}
}
else
{
// austragen
var subscriptionService = new SubscriptionService(Db);
subscriptionService.DeleteSubscription(subscription);
// Nachrücken
if (bookingList != null)
{
var succBooking = bookingList.GetSucceedingBooking();
if (succBooking != null)
{
succBooking.Subscription.OnWaitingList = false;
succeedingSubscription = succBooking.Subscription;
}
}
}
Db.SaveChanges();
transaction.Commit();
}
// Mail an Nachrücker versenden
if (succeedingSubscription != null)
{
var mailService = new SubscriptionMailService();
mailService.SendSucceedingEMail(course, succeedingSubscription);
var subscriber = GetUser(succeedingSubscription.UserId);
logger.InfoFormat("{0} ({1}) for [{2}]: set on participient list",
course.Name, course.ShortName, subscriber.UserName);
}
// jetzt neu abrufen und anzeigen
var model = GetBookingStateModel(course.Id);
return(PartialView("_CourseSummaryBookingBox", model));
}
public ActionResult Import(InvitationFileModel model)
{
var invitationList = CreateCheckModel(model);
var host = GetCurrentUser();
var studentService = new StudentService(Db);
/*
* if (!string.IsNullOrEmpty(invitationList.Error))
* return View("InvitationList", invitationList);
*/
foreach (var invitation in invitationList.Invitations)
{
var user = UserManager.FindByEmail(invitation.Email);
if (user == null)
{
var now = DateTime.Now;
user = new ApplicationUser
{
UserName = invitation.Email,
Email = invitation.Email,
FirstName = invitation.FirstName,
LastName = invitation.LastName,
Registered = now,
MemberState = MemberState.Student,
Remark = "CIE",
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
var result = UserManager.Create(user, "Cie98#lcl?");
if (result.Succeeded)
{
// analog Forget E-Mail Versand
string code = UserManager.GeneratePasswordResetToken(user.Id);
var mailModel = new ForgotPasswordMailModel
{
User = user,
Token = code,
CustomSubject = "Your NINE Account",
CustomBody = "",
Attachments = null,
IsNewAccount = true,
};
try
{
new MailController().InvitationMail(mailModel, host, "en").Deliver();
}
catch (SmtpFailedRecipientException ex)
{
invitation.Remark = ex.Message;
}
}
}
var student = studentService.GetCurrentStudent(user);
if (student == null)
{
student = new Student();
student.Created = DateTime.Now;
student.Curriculum = invitation.Curriculum;
student.FirstSemester = invitation.Semester;
student.UserId = user.Id;
Db.Students.Add(student);
}
if (invitation.Course != null)
{
var subscription =
invitation.Course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(user.Id));
if (subscription == null)
{
subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.UserId = user.Id;
subscription.OnWaitingList = invitation.OnWaitinglist;
subscription.Occurrence = invitation.Course.Occurrence;
subscription.HostRemark = invitation.Remark;
invitation.Course.Occurrence.Subscriptions.Add(subscription);
}
}
}
Db.SaveChanges();
return(View("InvitationList", invitationList));
}
public ActionResult Import(InvitationFileModel model)
{
var invitationList = CreateCheckModel(model);
var host = GetCurrentUser();
var studentService = new StudentService(Db);
/*
* if (!string.IsNullOrEmpty(invitationList.Error))
* return View("InvitationList", invitationList);
*/
foreach (var invitation in invitationList.Invitations)
{
var user = UserManager.FindByEmail(invitation.Email);
if (user == null)
{
var now = DateTime.Now;
user = new ApplicationUser
{
UserName = invitation.Email,
Email = invitation.Email,
FirstName = invitation.FirstName,
LastName = invitation.LastName,
Registered = now,
MemberState = MemberState.Student,
Remark = "CIE",
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
var result = UserManager.Create(user, "Cie98#lcl?");
}
var student = studentService.GetCurrentStudent(user);
if (student == null)
{
student = new Student();
student.Created = DateTime.Now;
student.Curriculum = invitation.Curriculum;
student.FirstSemester = invitation.Semester;
student.UserId = user.Id;
Db.Students.Add(student);
}
if (invitation.Course != null)
{
var subscription =
invitation.Course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(user.Id));
if (subscription == null)
{
subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.UserId = user.Id;
subscription.OnWaitingList = invitation.OnWaitinglist;
subscription.Occurrence = invitation.Course.Occurrence;
subscription.HostRemark = invitation.Remark;
invitation.Course.Occurrence.Subscriptions.Add(subscription);
}
}
}
Db.SaveChanges();
return(View("InvitationList", invitationList));
}
public ActionResult Subscribe(StudentSubscriptionModel model)
{
var org = GetMyOrganisation();
var semester = SemesterService.GetSemester(model.SemesterName.Trim());
if (semester == null)
{
ModelState.AddModelError("SemesterName", "Es existiert kein Semester mit dieser Bezeichnung");
return(View(model));
}
var courses = Db.Activities.OfType <Course>().Where(x =>
x.ShortName.Equals(model.CourseShortName.Trim()) &&
x.SemesterGroups.Any(g =>
g.Semester.Id == semester.Id && g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == org.Id)).ToList();
if (!courses.Any())
{
ModelState.AddModelError("CourseShortName", "Es existiert keine Lehrveranstaltung mit dieser Bezeichnung");
return(View(model));
}
if (courses.Count > 1)
{
ModelState.AddModelError("CourseShortName", $"Bezeichnung nicht eindeutig. Es existieren {courses.Count} Lehrveranstaltungen mit dieser Bezeichnung");
return(View(model));
}
var host = GetCurrentUser();
var course = courses.First();
var subscription = course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(model.User.Id));
if (subscription != null)
{
ModelState.AddModelError("CourseShortName", "Ist bereits in dieser Lehrveranstaltung eingetragen.");
return(View(model));
}
subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.UserId = model.User.Id;
subscription.OnWaitingList = false;
subscription.Occurrence = course.Occurrence;
course.Occurrence.Subscriptions.Add(subscription);
// wenn es ein Wahlverfahren gibt, dann als Prio 1
var lottery =
Db.Lotteries.FirstOrDefault(x => x.Occurrences.Any(y => y.Id == course.Occurrence.Id));
if (lottery != null)
{
subscription.Priority = 1;
var game = lottery.Games.FirstOrDefault(x => x.UserId.Equals(model.User.Id));
if (game == null)
{
game = new LotteryGame
{
Lottery = lottery,
UserId = subscription.UserId,
AcceptDefault = false,
CoursesWanted = lottery.MaxConfirm,
Created = DateTime.Now,
LastChange = DateTime.Now
};
lottery.Games.Add(game);
}
}
Db.SaveChanges();
// Bei Erfolg Mail versenden
var mailService = new SubscriptionMailService();
mailService.SendSubscriptionEMail(course, subscription, host);
return(RedirectToAction("CoursePlan", new { id = model.User.Id, semId = semester.Id }));
}
public ActionResult UploadDates(Assessment model, HttpPostedFileBase resultFile)
{
var user = GetCurrentUser();
var assessment = Db.Assessments.SingleOrDefault(x => x.Id == model.Id);
var member = assessment.Committee.Members.FirstOrDefault(x => !string.IsNullOrEmpty(x.Member.UserId) && x.Member.UserId.Equals(user.Id));
var userInfoService = new UserInfoService();
var errors = new List <string>();
if (resultFile == null)
{
return(null);
}
var officeHour = GetOfficeHour(assessment);
var bytes = new byte[resultFile.ContentLength];
resultFile.InputStream.Read(bytes, 0, resultFile.ContentLength);
var stream = new System.IO.MemoryStream(bytes);
var reader = new System.IO.StreamReader(stream, Encoding.Default);
var text = reader.ReadToEnd();
string[] lines = text.Split('\n');
foreach (var line in lines)
{
string newline = line.Trim();
if (!string.IsNullOrEmpty(newline))
{
string[] words = newline.Split(';');
var firstName = words[0].Trim();
var lastName = words[1].Trim();
var email = words[2].Trim();
var date = DateTime.ParseExact(words[3].Trim(), "dd.MM.yyyy", null);
var from = TimeSpan.ParseExact(words[4].Trim(), @"h\:mm", null);
var until = TimeSpan.ParseExact(words[5].Trim(), @"h\:mm", null);
var candUser = userInfoService.GetUserByEmail(email);
if (candUser == null)
{
var msg = $"Kein Benutzer für E-Mail Adresse {email} vorhanden";
errors.Add(msg);
continue;
}
if (!(candUser.FirstName.Trim().ToLower().Equals(firstName.ToLower()) &&
candUser.LastName.Trim().ToLower().Equals(lastName.ToLower())))
{
var msg = $"Angaben für den Benutzer {email} stimmen nicht überein: Datei: {firstName} {lastName}, Datenbank: {candUser.FirstName} {candUser.LastName}";
errors.Add(msg);
continue;
}
var candidate = assessment.Candidatures.SingleOrDefault(x => x.UserId.Equals(candUser.Id));
if (candidate == null)
{
var msg = $"Benutzer {email} nicht im Verfahren dabei";
errors.Add(msg);
continue;
}
if (candidate.IsAccepted != true)
{
var msg = $"Benutzer {email} wurde bisher nicht als angenommen markiert";
errors.Add(msg);
continue;
}
// so jetzt Datum und Uhrzeit Termin finden hinzufügen und/oder Termin anlegen
var begin = date.Add(from);
var end = date.Add(until);
var ohDate = officeHour.Dates.SingleOrDefault(x => x.Begin == begin && x.End == end);
if (ohDate == null)
{
ohDate = new ActivityDate
{
Activity = officeHour,
Begin = begin,
End = end,
Occurrence = new Occurrence
{
IsAvailable = true,
Capacity = 0,
FromIsRestricted = false,
UntilIsRestricted = false,
UntilTimeSpan = null,
IsCanceled = false,
IsMoved = false,
}
};
Db.ActivityDates.Add(ohDate);
}
// die subscription suchen
var ohSubDate = officeHour.Dates.FirstOrDefault(x =>
x.Occurrence.Subscriptions.Any(s => s.UserId.Equals(candUser.Id)));
if (ohSubDate == null)
{
var ohSubscription = new OccurrenceSubscription
{
Occurrence = ohDate.Occurrence,
OnWaitingList = false,
UserId = candUser.Id,
TimeStamp = DateTime.Now
};
Db.Subscriptions.Add(ohSubscription);
}
else
{
var msg = $"Benutzer {email} hat schon einen Termin am {ohSubDate.Begin}";
errors.Add(msg);
continue;
}
}
}
if (errors.Any())
{
return(View("_Errors", errors));
}
Db.SaveChanges();
return(RedirectToAction("Acceptance", new { id = assessment.Id }));
}
private void TryToHelpJinx()
{
foreach (var game in Games)
{
var studentLots = game.Lots.OrderBy(x => x.Priority).ToList();
// Student ist Ober-Pechvogel, wenn er gar nichts erhalten hat => zuerst 1 Kurs
// gar nichts: Keinen Platz und auch kein Los auf der Warteliste
var isJinx = !game.Seats.Any() && studentLots.All(x => x.IsValid && x.Subscription.OnWaitingList);
if (isJinx)
{
// Suche einen Kurs, der noch freie Plätze hat und in dem er noch nicht drin ist
var availableCourse = LotPots.Where(x =>
!x.Course.Occurrence.Subscriptions.Any(s => s.UserId.Equals(game.UserId)) &&
x.RemainingSeats > 0).OrderByDescending(x => x.RemainingSeats).FirstOrDefault();
if (availableCourse == null)
{
game.Message = "Im gesamten Wahlverfahren stehen keine freien Plätze mehr zur Verfügung.";
}
else
{
if (game.AcceptDefault)
{
// eine neue Eintragung
var subscription = new OccurrenceSubscription();
subscription.TimeStamp = DateTime.Now;
subscription.UserId = game.UserId;
subscription.OnWaitingList = false;
subscription.Priority = 0;
subscription.Occurrence = availableCourse.Course.Occurrence;
// Die Subscription hinzufügen
availableCourse.Course.Occurrence.Subscriptions.Add(subscription);
// Die Bookinglist aktualisieren
availableCourse.BookingList.Bookings.Add(new Booking.Data.Booking
{
Student = game.Student,
Subscription = subscription
});
var lot = new DrawingLot();
lot.IsTouched = true;
lot.IsValid = true;
lot.Message = "Mindestens mal eine Lehrveranstaltung für den Pechvogel";
lot.Subscription = subscription;
lot.Course = availableCourse.Course;
game.Lots.Add(lot);
availableCourse.Lots.Add(lot);
/*
* var lotPot = LotPots.SingleOrDefault(x => x.Course.Id == availableCourse.Course.Id);
* lotPot.Lots.Add(lot);
*/
}
else
{
game.Message =
"Es hätte noch einen Platz in einer anderen Lehrveranstaltung gegeben.";
}
}
}
}
}
