public List<RegistrationParticipation> GetFilteredParticipationList(string userId, string studentid, string lastName, string firstName, string majorCode, int? ceremonyId, string collegeCode, List<Ceremony> ceremonies, TermCode termCode)
{
Check.Require(!string.IsNullOrEmpty(userId), "userid is required");
if (ceremonies == null) ceremonies = _ceremonyService.GetCeremonies(userId, termCode ?? TermService.GetCurrent());
var ceremonyIds = ceremonies.Select(a => a.Id).ToList();
//used to be a.Major.Major.Id.Contains on line 75, but that's not valid. Changed to check for either major or consolidation major
var query = _registrationParticipationRepository.Queryable.Where(a =>
a.Registration.TermCode == termCode
&& !a.Cancelled && !a.Registration.Student.SjaBlock && !a.Registration.Student.Blocked
&& ceremonies.Contains(a.Ceremony)
&& a.Major.College.Id.Contains(string.IsNullOrEmpty(collegeCode) ? string.Empty : collegeCode)
&& ceremonyIds.Contains(a.Ceremony.Id)
&& (a.Registration.Student.StudentId.Contains(string.IsNullOrEmpty(studentid) ? string.Empty : studentid))
&& (a.Registration.Student.LastName.Contains(string.IsNullOrEmpty(lastName) ? string.Empty : lastName))
&& (a.Registration.Student.FirstName.Contains(string.IsNullOrEmpty(firstName) ? string.Empty : firstName))
&& (a.Major.ConsolidationMajor.Id.Contains(string.IsNullOrEmpty(majorCode) ? string.Empty : majorCode) || a.Major.Id.Contains(string.IsNullOrEmpty(majorCode) ? string.Empty : majorCode))
);
if (ceremonyId.HasValue && ceremonyId.Value > 0) query = query.Where(a => a.Ceremony.Id == ceremonyId.Value);
return query.ToList();
}
public List<Registration> GetFilteredList(string userId, string studentid, string lastName, string firstName, string majorCode, int? ceremonyId, string collegeCode, List<Ceremony> ceremonies = null, TermCode termCode = null)
{
Check.Require(!string.IsNullOrEmpty(userId), "userid is required.");
if (ceremonies == null) ceremonies = _ceremonyService.GetCeremonies(userId, termCode ?? TermService.GetCurrent());
var ceremonyIds = ceremonies.Select(a => a.Id).ToList();
var query = _registrationParticipationRepository.Queryable.Where(a =>
a.Registration.TermCode == termCode
//&& !a.Registration.Student.SjaBlock && !a.Registration.Cancelled
&& ceremonies.Contains(a.Ceremony)
&& a.Major.College.Id.Contains(string.IsNullOrEmpty(collegeCode) ? string.Empty : collegeCode)
&& ceremonyIds.Contains(a.Ceremony.Id)
&& (a.Registration.Student.StudentId.Contains(string.IsNullOrEmpty(studentid) ? string.Empty : studentid))
&& (a.Registration.Student.LastName.Contains(string.IsNullOrEmpty(lastName) ? string.Empty : lastName))
&& (a.Registration.Student.FirstName.Contains(string.IsNullOrEmpty(firstName) ? string.Empty : firstName))
);
if (ceremonyId.HasValue && ceremonyId.Value > 0)
query = query.Where(a => a.Ceremony.Id == ceremonyId.Value);
var regIds = query.Select(a => a.Registration.Id).ToList();
return _registrationRepository.Queryable.Where(a => regIds.Contains(a.Id)).ToList();
}
public void TestConstructorWithParametersSetsExpectedValues()
{
#region Arrange
var termCode = new TermCode();
termCode.Name = "Tname";
var student = new Student("pidm", "studentId", "FName", "MI", "LName", 12.3m, 100m, "email", "login", termCode);
#endregion Arrange
#region Act
#endregion Act
#region Assert
Assert.IsNotNull(student.Majors);
Assert.AreEqual(0, student.Majors.Count);
Assert.AreEqual(DateTime.Now.Date, student.DateAdded.Date);
Assert.AreEqual(DateTime.Now.Date, student.DateUpdated.Date);
Assert.AreEqual("pidm", student.Pidm);
Assert.AreEqual("studentId", student.StudentId);
Assert.AreEqual("FName", student.FirstName);
Assert.AreEqual("MI", student.MI);
Assert.AreEqual("LName", student.LastName);
Assert.AreEqual(12.3m, student.CurrentUnits);
Assert.AreEqual(100m, student.EarnedUnits);
Assert.AreEqual("email", student.Email);
Assert.AreEqual("login", student.Login);
Assert.AreEqual("Tname", student.TermCode.Name);
Assert.AreNotEqual(Guid.Empty, student.Id);
#endregion Assert
}
public ActionResult Edit(string id, TermCode termCode)
{
ModelState.Clear();
var termCodeToUpdate = Repository.OfType<TermCode>().Queryable.Single(a => a.Id == id);
termCodeToUpdate.LandingText = termCode.LandingText;
termCodeToUpdate.RegistrationWelcome = termCode.RegistrationWelcome;
// copy the dates
termCodeToUpdate.RegistrationBegin = termCode.RegistrationBegin;
termCodeToUpdate.RegistrationDeadline = termCode.RegistrationDeadline;
termCodeToUpdate.CapAndGownDeadline = termCode.CapAndGownDeadline;
termCodeToUpdate.FileToGraduateDeadline = termCode.FileToGraduateDeadline;
termCodeToUpdate.RegistrationPetitionDeadline = termCode.RegistrationPetitionDeadline;
termCodeToUpdate.TransferValidationMessagesTo(ModelState);
if (ModelState.IsValid)
{
Repository.OfType<TermCode>().EnsurePersistent(termCodeToUpdate);
Message = id + " Term Code Saved.";
TermService.UpdateCurrent(termCodeToUpdate);
return this.RedirectToAction(a => a.Index());
}
Message = id + " Unable to save.";
return View(termCode);
}
protected void ImageButtonEditLocation_Click(object sender, ImageClickEventArgs e)
{
try
{
GridViewRow row = ((ImageButton)sender).Parent.Parent as GridViewRow;
HiddenField hiddenFieldLocationOID = (HiddenField)row.Cells[0].FindControl("HiddenFieldLocationOID");
int chapterOID = Convert.ToInt32(hiddenFieldLocationOID.Value);
TermCode termCode = new TermCode();
termCode = termCode.GetTermCodeByTermCodeOID(chapterOID);
if (termCode != null)
{
ViewState["TermCode"] = termCode;
TextBoxTermCode.Text = termCode.TermCodeName;
}
else
{
ViewState["TermCode"] = null;
}
}
catch (Exception ex)
{
}
}
public bool AddTermCode(TermCode termCode)
{
bool result = false;
using (OdbcConnection connection = new OdbcConnection(connectionString))
{
using (OdbcCommand command = new OdbcCommand())
{
command.Connection = connection;
command.CommandText = "{CALL TermCode_insert(?,?)}";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@AssessmentOID", termCode.AssessmentOID);
command.Parameters.AddWithValue("@TermCodeName", termCode.TermCodeName);
connection.Open();
int n = command.ExecuteNonQuery();
if (n > 0)
result = true;
else
result = false;
}
}
return result;
}
public static AdminRegistrationViewModel Create(IRepository repository, IMajorService majorService, ICeremonyService ceremonyService, IRegistrationService registrationService, TermCode termCode, string userId, string studentid, string lastName, string firstName, string majorCode, int? ceremonyId, string collegeCode)
{
Check.Require(repository != null, "Repository is required.");
Check.Require(majorService != null, "Major service is required.");
Check.Require(ceremonyService != null, "ceremonyService is required.");
var ceremonies = ceremonyService.GetCeremonies(userId, termCode);
var colleges = new List<College>();
foreach(var a in ceremonies) colleges.AddRange(a.Colleges);
var viewModel = new AdminRegistrationViewModel()
{
MajorCodes = majorService.GetByCeremonies(userId, ceremonies),
Colleges = colleges.Distinct().ToList(),
Ceremonies = ceremonies,
studentidFilter = studentid,
lastNameFilter = lastName,
firstNameFilter = firstName,
majorCodeFilter = majorCode,
ceremonyFilter = ceremonyId ?? -1,
collegeFilter = collegeCode,
Participations = registrationService.GetFilteredParticipationList(userId, studentid, lastName, firstName, majorCode, ceremonyId, collegeCode, ceremonies, termCode)
};
//if (!string.IsNullOrEmpty(majorCode))
// viewModel1111 = viewModel.Registrations.Where(a => a.Student.StrMajorCodes.Contains(majorCode));
return viewModel;
}
public static AdminExtraTicketPetitionViewModel Create(IRepository repository, ICeremonyService ceremonyService, IPetitionService petitionService, IPrincipal currentUser, TermCode termCode, int? ceremonyId, bool? viewAll)
{
Check.Require(repository != null, "Repository is required.");
// set the default to false
viewAll = viewAll ?? false;
var ceremonies = ceremonyService.GetCeremonies(currentUser.Identity.Name, termCode);
//var ceremonyIds = ceremonies.Select(a => a.Id).ToList();
var viewModel = new AdminExtraTicketPetitionViewModel()
{
Ceremonies = ceremonies,
Ceremony = ceremonyId.HasValue ? repository.OfType<Ceremony>().GetNullableById(ceremonyId.Value) : null,
ViewAll = viewAll.Value
};
// has a ceremony been selected and does the current user have access
if (ceremonyId.HasValue && ceremonyService.HasAccess(ceremonyId.Value, currentUser.Identity.Name))
{
if (viewAll.Value)
{
viewModel.RegistrationParticipations = viewModel.Ceremony.RegistrationParticipations.Where(a => a.ExtraTicketPetition != null).ToList();
}
else
{
viewModel.RegistrationParticipations = petitionService.GetPendingExtraTicket(currentUser.Identity.Name, ceremonyId.Value, termCode);
}
}
return viewModel;
}
protected void ButtonSubmit_Click(object sender, EventArgs e)
{
if (TextBoxTermCode.Text.Trim() == "")
{
TextBoxTermCode.Focus();
return;
}
TermCode termCode = new TermCode();
bool status = false;
if (ViewState["TermCode"] == null)
{
termCode.AssessmentOID = Convert.ToInt32(ViewState["AssessmentOID"]);
termCode.TermCodeName = TextBoxTermCode.Text.Trim();
status = termCode.AddTermCode(termCode);
if (status)
{
TextBoxTermCode.Text = "";
this.Initialize(termCode.AssessmentOID);
}
}
else
{
termCode = ViewState["TermCode"] as TermCode;
termCode.TermCodeName = TextBoxTermCode.Text.Trim();
status = termCode.UpdateTermCode(termCode);
if (status)
{
ViewState["TermCode"] = null;
TextBoxTermCode.Text = "";
this.Initialize(termCode.AssessmentOID);
}
}
}
/// <summary>
/// Adds the vTermCode to TermCodes, then it should redirect to the edit.
/// </summary>
/// <returns></returns>
public ActionResult Add(string termCodeId)
{
var vTermCode = Repository.OfType<vTermCode>().Queryable.Single(a => a.Id == termCodeId);
var termCode = new TermCode(vTermCode);
termCode.IsActive = false;
Repository.OfType<TermCode>().EnsurePersistent(termCode);
return this.RedirectToAction(a => a.Edit(termCode.Id));
}
public static AdminStudentViewModel Create(IRepository repository, IMajorService majorService, ICeremonyService ceremonyService, TermCode termCode, string studentid, string lastName, string firstName, string majorCode, string college, string userId)
{
Check.Require(repository != null, "Repository is required.");
// build a list of majors that the current user has assigned to their ceremonies
var ceremonies = ceremonyService.GetCeremonies(userId, TermService.GetCurrent());
var majors = ceremonies.SelectMany(a => a.Majors).Where(a => a.ConsolidationMajor == null && a.IsActive).ToList();
var colleges = ceremonies.SelectMany(a => a.Colleges).Distinct().ToList();
var viewModel = new AdminStudentViewModel()
{
MajorCodes = majors,
studentidFilter = studentid,
lastNameFilter = lastName,
firstNameFilter = firstName,
majorCodeFilter = majorCode,
Colleges = colleges
};
var query = repository.OfType<Student>().Queryable.Where(a =>
a.TermCode == termCode
&& (a.StudentId.Contains(string.IsNullOrEmpty(studentid) ? string.Empty : studentid.Trim()))
&& (a.LastName.Contains(string.IsNullOrEmpty(lastName) ? string.Empty : lastName.Trim()))
&& (a.FirstName.Contains(string.IsNullOrEmpty(firstName) ? string.Empty : firstName.Trim()))
);
// get the list of students with optional filters
var students = query.ToList();
if (colleges.Count == 1)
{
var coll = colleges.First();
students = students.Where(a => a.StrColleges.Contains(coll.Id)).ToList();
}
if (!string.IsNullOrEmpty(majorCode)) students = students.Where(a => a.StrMajorCodes.Contains(majorCode)).ToList();
if (!string.IsNullOrEmpty(college)) students = students.Where(a => a.StrColleges.Contains(college)).ToList();
// get all active registrations
var reg = repository.OfType<RegistrationParticipation>().Queryable.Where(
a => a.Ceremony.TermCode == termCode).// && !a.Registration.Student.SjaBlock && !a.Registration.Cancelled).
ToList();
var regStudents = reg.Select(a => a.Registration.Student);
viewModel.StudentRegistrationModels = new List<StudentRegistrationModel>();
foreach(var s in students.Distinct().ToList())
{
var reged = regStudents.Any(a => a == s);
viewModel.StudentRegistrationModels.Add(new StudentRegistrationModel(s, reged));
}
return viewModel;
}
public List<RegistrationPetition> GetPendingRegistration(string userId, TermCode termCode, List<int> ceremonyIds = null)
{
// get the list of my valid ceremonies
if (ceremonyIds == null) ceremonyIds = _ceremonyService.GetCeremonyIds(userId, termCode ?? TermService.GetCurrent());
var registration =
_registrationPetitionRepository.Queryable.Where(a => a.IsPending && ceremonyIds.Contains(a.Ceremony.Id));
return registration.ToList();
}
public virtual List<int> GetCeremonyIds(string userId, TermCode termCode = null)
{
var query = from a in _repository.OfType<CeremonyEditor>().Queryable
where a.User.LoginId == userId
select a;
if (termCode != null)
{
query = query.Where(a => a.Ceremony.TermCode == termCode);
}
return query.Select(a => a.Ceremony.Id).ToList();
}
/// <summary>
/// Gets a list of user's pending extra ticket petitions.
/// </summary>
/// <param name="userId"></param>
/// <param name="termCode"></param>
/// <param name="ceremonyId"></param>
/// <returns>Return registration so user has access to name and what not</returns>
public List<RegistrationParticipation> GetPendingExtraTicket(string userId, int ceremonyId, TermCode termCode = null)
{
// get the list of my valid ceremonies
var participations = _registrationParticipationRepository.Queryable.Where(a => a.Ceremony.Id == ceremonyId
&& !a.Cancelled
&& a.ExtraTicketPetition != null
&& a.ExtraTicketPetition.IsPending).ToList();
// filter more so that only ones who are valid for tickets are returned
participations = participations.Where(a => a.IsValidForTickets).ToList();
return participations;
}
public virtual List<Ceremony> GetCeremonies(string userId, TermCode termCode = null)
{
var ceremonyIds = GetCeremonyIds(userId, termCode);
var query = from a in _repository.OfType<Ceremony>().Queryable
where ceremonyIds.Contains(a.Id)
select a;
if (termCode != null)
{
query = query.Where(a => a.TermCode == termCode);
}
return query.ToList();
}
protected void ImageButtonDeleteLocation_Click(object sender, ImageClickEventArgs e)
{
try
{
GridViewRow row = ((ImageButton)sender).Parent.Parent as GridViewRow;
HiddenField hiddenFieldLocationOID = (HiddenField)row.Cells[0].FindControl("HiddenFieldLocationOID");
int locationOID = Convert.ToInt32(hiddenFieldLocationOID.Value);
TermCode termCode = new TermCode();
bool status = termCode.DeleteTermCode(locationOID);
if (status)
{
this.Initialize(termCode.AssessmentOID);
}
}
catch (Exception ex)
{
}
}
public static AdminPetitionsViewModel Create(IRepository repository, ICeremonyService ceremonyService, IPetitionService petitionService, string userId, TermCode termCode)
{
Check.Require(repository!= null, "Repository is required.");
//var viewModel = new AdminPetitionsViewModel()
// {
// PendingExtraTicket = repository.OfType<Registration>().Queryable.Where(a => a.ExtraTicketPetition != null && a.ExtraTicketPetition.IsPending).ToList(),
// Ceremonies = repository.OfType<Ceremony>().Queryable.Where(a=>a.TermCode == TermService.GetCurrent()),
// PendingRegistrationPetitions = repository.OfType<RegistrationPetition>().Queryable.Where(
// a=>a.TermCode == TermService.GetCurrent() && a.IsPending).ToList()
// };
var ceremonies = ceremonyService.GetCeremonies(userId, termCode);
var ceremonyIds = ceremonies.Select(a => a.Id).ToList();
var viewModel = new AdminPetitionsViewModel()
{
//PendingExtraTicket = petitionService.GetPendingExtraTicket(userId, termCode, ceremonyIds),
PendingRegistrationPetitions = petitionService.GetPendingRegistration(userId, termCode, ceremonyIds),
Ceremonies = ceremonies
};
return viewModel;
}
/// <summary>
/// Returns ceremonies that this student is eligible for or are eligible to petition for
/// </summary>
/// <param name="majors"></param>
/// <returns>List of ceremonies, if empty, student not eligible for ceremony is system.</returns>
public virtual List<Ceremony> StudentEligibility(List<MajorCode> majors, decimal totalUnits, TermCode termCode = null, int? ceremonyIdOverride = null)
{
// get term code if we don't have one
if (termCode == null) termCode = TermService.GetCurrent();
// load all valid ceremonies for current term
var ceremonies = _repository.OfType<Ceremony>().Queryable.Where(a => a.TermCode == termCode).ToList();
var eligibleCeremonies = new List<Ceremony>();
// find ceremonies, student is eligible for
foreach (var a in ceremonies)
{
// make sure units are enough
if (totalUnits >= a.PetitionThreshold)
{
// go through each of the student's major
foreach (var b in majors)
{
// if major is in ceremony
if (a.Majors.Contains(b))
{
// add to the list of valid
eligibleCeremonies.Add(a);
}
}
}
}
// if this student is eligible for access to another ceremony, add in that special ceremony
if (ceremonyIdOverride.HasValue)
{
var ceremonyOverride = _repository.OfType<Ceremony>().GetNullableById(ceremonyIdOverride.Value);
Check.Ensure(ceremonyOverride != null, "ceremonyOverride is required.");
Check.Ensure(ceremonies.Select(a => a.Id).Contains(ceremonyOverride.Id), "Override ceremony is not is the list of ceremonies for the targetted term.");
eligibleCeremonies.Add(ceremonyOverride);
}
// return distinct list
return eligibleCeremonies.Distinct().ToList();
}
public static Ceremony DeteremineCeremony(IRepository repository, RegistrationPetition registrationPetition, TermCode termCode)
{
return repository.OfType<Ceremony>().Queryable.Where(a => a.Majors.Contains(registrationPetition.MajorCode) && a.TermCode == termCode).FirstOrDefault();
}
public static TermCode TermCode(int? count)
{
var rtValue = new TermCode();
rtValue.Name = "Name" + count.Extra();
return rtValue;
}
public TermCode GetTermCodeByTermCodeOID(int TCOID)
{
TermCode termCode = new TermCode();;
using (OdbcConnection connection = new OdbcConnection(connectionString))
{
using (OdbcCommand command = new OdbcCommand())
{
command.Connection = connection;
command.CommandText = "{CALL TermCode_ByTermCodeOID(?)}";
command.CommandType = CommandType.StoredProcedure;
//Set Parameter Value
command.Parameters.AddWithValue("@TCOID", TCOID);
//Open connection
connection.Open();
//Read using reader
using (OdbcDataReader dataReader = command.ExecuteReader())
{
//Question q = new Question();
while (dataReader.Read())
{
termCode = new TermCode();
termCode.TermCodeOID = Convert.ToInt32(dataReader["TermCodeOID"]);
termCode.AssessmentOID = Convert.ToInt32(dataReader["AssessmentOID"]);
termCode.TermCodeName = Convert.ToString(dataReader["TermCodeName"]);
}
}
}
}
return termCode;
}
public static RegistrationDataViewModel Create(IRepository repository, ICeremonyService ceremonyService, string userId, TermCode termCode)
{
Check.Require(repository != null, "Repository is required.");
//var viewModel = new RegistrationDataViewModel();
//viewModel.RegistrationData = new List<RegistrationData>();
//var ceremonies = ceremonyService.GetCeremonies(userId, termCode);
//viewModel.RegistrationData = ceremonies.Select(a => new RegistrationData()
// {
// TermCode = a.TermCode,
// Ceremony = a,
// Registrants = a.RegistrationParticipations.Count(),
// CancelledRegistrants = a.RegistrationParticipations.Count(),
// RegistrationPetitionsSubmitted = a.RegistrationPetitions.Count,
// RegistrationPetitionsApproved =
// a.RegistrationPetitions.Where(
// b => b.IsApproved && !b.IsPending).Count(),
// TicketsRequested = a.ProjectedTicketCount,
// ExtraTicketsRequested = a.ProjectedTicketCount,
// TotalTickets = a.TotalTickets
// }).ToList();
//return viewModel;
var viewModel = new RegistrationDataViewModel();
// load all ceremonies that a user has access to
var ceremonies = ceremonyService.GetCeremonies(userId);
viewModel.RegistrationData = (from a in ceremonies
select new RegistrationData()
{
TermCode = a.TermCode,
Ceremony = a,
Registrants = a.RegistrationParticipations.Where(b => !b.Cancelled).Count(),
CancelledRegistrants = a.RegistrationParticipations.Where(b => b.Cancelled).Count(),
RegistrationPetitionsSubmitted = a.RegistrationPetitions.Count,
RegistrationPetitionsApproved = a.RegistrationPetitions.Where(b => b.IsApproved).Count(),
ExtraTicketPetitionsSubmitted = a.RegistrationParticipations.Where(b => b.ExtraTicketPetition != null).Count(),
ExtraTicketPetitionsApproved = a.RegistrationParticipations.Where(b => b.ExtraTicketPetition != null && b.ExtraTicketPetition.IsApproved).Count(),
TicketsPavilion = a.TicketCount,
TicketsBallroom = a.TicketStreamingCount,
TicketsByPetition = a.RegistrationParticipations.Where(b => b.ExtraTicketPetition != null && b.ExtraTicketPetition.IsApprovedCompletely).Sum(b => b.ExtraTicketPetition.TotalTickets)
}).ToList();
return viewModel;
}
public Registration GetPriorRegistration(Student student, TermCode termCode)
{
//Get any prior registration for the given student. There should be either none or one
return _registrationRepository.Queryable.SingleOrDefault(x => x.Student == student && x.RegistrationParticipations[0].Ceremony.TermCode == termCode);
}
private void Initialize(int assessmentOID)
{
TermCode termCode = new TermCode();
Collection<TermCode> termCodeList = termCode.GetTermCodeByAssessmentOID(assessmentOID);
GridViewLocations.DataSource = termCodeList;
GridViewLocations.DataBind();
}
private void Initialize(int assessmentOID)
{
LabelMessage.Text = "";
LabelStatus.Text = "";
Collection<TermCode> termCodeList = new TermCode().GetTermCodeByAssessmentOID(assessmentOID);
ViewState["TermCodeList"] = termCodeList;
foreach (TermCode termCode in termCodeList)
{
CheckBoxListTermCode.Items.Add(termCode.TermCodeName);
}
this.ShowEmailBody(assessmentOID);
}
public ActionResult Create(CeremonyEditModel ceremonyEditModel)
{
ModelState.Clear();
if (string.IsNullOrEmpty(ceremonyEditModel.Term))
{
ModelState.AddModelError("Term Code", "Term code must be selected.");
}
var termCode = _termRepository.GetNullableById(ceremonyEditModel.Term);
if (termCode == null && !string.IsNullOrEmpty(ceremonyEditModel.Term))
{
// term code doesn't exist, create a new one
var vTermCode = _vTermRepository.GetNullableById(ceremonyEditModel.Term);
termCode = new TermCode(vTermCode);
}
Ceremony ceremony = new Ceremony();
CopyCeremony(ceremony, ceremonyEditModel.Ceremony, ceremonyEditModel.CeremonyMajors, ceremonyEditModel.Colleges, ceremonyEditModel.TicketDistributionMethods);
ceremony.TermCode = termCode;
ceremony.AddEditor(_userService.GetCurrentUser(User), true);
// fix the time on the end dates, so it ends on
ceremony.TransferValidationMessagesTo(ModelState);
if (ModelState.IsValid)
{
// save
_termRepository.EnsurePersistent(termCode, true);
Repository.OfType<Ceremony>().EnsurePersistent(ceremony);
TermService.UpdateCurrent(termCode); // update the cache.
// null out the current list of ceremonies the user has access to
_ceremonyService.ResetUserCeremonies();
// display a message
Message = "Ceremony has been created.";
// redirect to the list
return this.RedirectToAction(a => a.Edit(ceremony.Id));
}
// redirect back to the page
var viewModel = CeremonyViewModel.Create(Repository, User, _majorService, ceremony);
viewModel.Ceremony = ceremony;
return View(viewModel);
}
public bool CheckExisting(string login, TermCode term, string studentId = null)
{
return _studentRepository.Queryable.Where(a => (a.Login == login || (!string.IsNullOrEmpty(studentId) && a.StudentId == studentId)) && a.TermCode == term).Any();
}
public static void UpdateCurrent(TermCode termCode)
{
TermCode = termCode;
}
