public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
////////////////////////////////////////////////////////////
// Step #1:
// Check to see if records exists
////////////////////////////////////////////////////////////
var lvProgramEnrollment = await _context.ProgramEnrollments
.Include(p => p.LMSProgram)
.SingleOrDefaultAsync(m => m.ProgramEnrollmentID == id);
////////////////////////////////////////////////////////////
// Return "Not Found" if record doesn't exist
////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
return(NotFound());
}
////////////////////////////////////////////////////////////
// Step #2:
// Now that record exists, make sure that the logged-in user
// is authorized to withdraw this program enrollment
////////////////////////////////////////////////////////////
var loggedInUserID = _userManager.GetUserId(User);
lvProgramEnrollment = null;
lvProgramEnrollment = await _context.ProgramEnrollments
.Where(pe => pe.StudentUserId == loggedInUserID && pe.ProgramEnrollmentID == id)
.Include(p => p.LMSProgram)
.SingleOrDefaultAsync();
/////////////////////////////////////////////////////////////
// We already know that record exists from Step #1 so if we
// get a "Not Found" in Step #2, we know it's because the
// logged-in user is not authorized to withdraw this
// program enrollment.
/////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
return(Unauthorized());
}
////////////////////////////////////////////////////////////
// Retrieve the correct StatusTransition
////////////////////////////////////////////////////////////
StatusTransition lvStatusTranstion = null;
//////////////////////////////////////////////////////////////////////
// STATUS TRANSITION: PENDING TO WITHDRAEN
//////////////////////////////////////////////////////////////////////
if (lvProgramEnrollment.StatusCode.Equals(StatusCodeConstants.PENDING))
{
lvStatusTranstion = await _context.StatusTransitions
.Where(st => st.TransitionCode == TransitionCodeConstants.PENDING_TO_WITHDRAWN)
.SingleOrDefaultAsync();
}
//////////////////////////////////////////////////////////////////////
// STATUS TRANSITION: APPROVED TO WITHDRAEN
//////////////////////////////////////////////////////////////////////
if (lvProgramEnrollment.StatusCode.Equals(StatusCodeConstants.APPROVED))
{
lvStatusTranstion = await _context.StatusTransitions
.Where(st => st.TransitionCode == TransitionCodeConstants.APPROVED_TO_WITHDRAWN)
.SingleOrDefaultAsync();
}
////////////////////////////////////////////////////////////////
// Create EnrollmentHistory using the correct StatusTranistion
////////////////////////////////////////////////////////////////
var lvEnrollmentHistory = new EnrollmentHistory()
{
StatusTransitionID = lvStatusTranstion.StatusTransitionID,
ActorUserId = _userManager.GetUserId(User),
ActorRemarks = Input.Remarks,
DateCreated = DateTime.Now
};
////////////////////////////////////////////////////////////
// Instantiate EnrollmentHistory Collection, if necessary
////////////////////////////////////////////////////////////
if (lvProgramEnrollment.EnrollmentHistory == null)
{
lvProgramEnrollment.EnrollmentHistory = new List <EnrollmentHistory>();
}
///////////////////////////////////////////////////////////////////
// Add newly created EnrollmentHistory with StatusTransition
// to ProgramEnrollment's EnrollmentHistory Collection
///////////////////////////////////////////////////////////////////
lvProgramEnrollment.EnrollmentHistory.Add(lvEnrollmentHistory);
/////////////////////////////////////////////////////////////////
// Update ProgramEnrollment Record with
// 1. EnrollmentStatus of "WITHDRAWN"
// 2. ApproverUserId (logged-in user)
// 3. EnrollmentHistory (PENDING TO WiTHDRAWN)
/////////////////////////////////////////////////////////////////
lvProgramEnrollment.StatusCode = StatusCodeConstants.WITHDRAWN;
lvProgramEnrollment.ApproverUserId = _userManager.GetUserId(User);
_context.ProgramEnrollments.Update(lvProgramEnrollment);
await _context.SaveChangesAsync();
////////////////////////////////////////////////////////////////////////////////////
// Send email notification to approvers who have their EmailNotify flag set to true
////////////////////////////////////////////////////////////////////////////////////
IList <ProgramApprover> approverList = await _context.ProgramApprovers
.Where(pa => pa.LMSProgramID == lvProgramEnrollment.LMSProgramID && pa.EmailNotify == true)
.Include(pa => pa.Approver)
.Include(pa => pa.LMSProgram)
.AsNoTracking()
.ToListAsync();
ApplicationUser student = await GetCurrentUserAsync();
foreach (ProgramApprover approverObj in approverList)
{
string email = approverObj.Approver.Email;
string subject = "Program Enrollment Withdrawal (" + approverObj.LMSProgram.LongName + ")";
string message = student.FullName + " has withdrawn his/her enrollment in " + approverObj.LMSProgram.LongName;
await _emailSender.SendEmailAsync(email, subject, message);
}
////////////////////////////////////////////////////////////////////////////////////
// Send email notification to LMS Program's common inbox (if any)
////////////////////////////////////////////////////////////////////////////////////
LMSProgram lmsProgram = await _context.LMSPrograms
.Where(p => p.LMSProgramID == lvProgramEnrollment.LMSProgramID && p.CommonInbox != null)
.AsNoTracking()
.SingleOrDefaultAsync();
if (String.IsNullOrEmpty(lmsProgram.CommonInbox) == false)
{
string email = lmsProgram.CommonInbox;
string subject = "Program Enrollment Withdrawal (" + lmsProgram.LongName + ")";
string message = student.FullName + " has withdrawn his/her enrollment in " + lmsProgram.LongName;
await _emailSender.SendEmailAsync(email, subject, message);
}
/////////////////////////////////////////////////////////////////
// Redirect to Student Index Page
/////////////////////////////////////////////////////////////////
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync(int programEnrollmentID, string statusCode, string statusTransitionCode)
{
////////////////////////////////////////////////////////////
// Step #1:
// Check to see if records exists
////////////////////////////////////////////////////////////
var lvProgramEnrollment = await _dbContext.ProgramEnrollments
.Where(pe => pe.ProgramEnrollmentID == programEnrollmentID)
.AsNoTracking()
.SingleOrDefaultAsync();
////////////////////////////////////////////////////////////
// Return "Not Found" if record doesn't exist
////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
_logger.LogInformation("[Approvals][ReviewModel][OnPostAsync] => ProgramEnrollment NOT FOUND ProgramEnrollmentID '" + programEnrollmentID + "'");
return(NotFound());
}
////////////////////////////////////////////////////////////
// Step #2:
// Now that record exists, make sure that the logged-in user
// is authorized to edit (approver/deny) enrollment
// applications for this particular LMS Program.
//////////////////////////////////////////////////////////////////////////
// PostgreSQL
/////////////////////////////////////////////////////////////////////////
// var sql = " SELECT * "
// + " FROM " + MiscConstants.DB_SCHEMA_NAME + ".\"ProgramEnrollment\" "
// + " WHERE \"ProgramEnrollmentID\" = {0} "
// + " AND \"LMSProgramID\" "
// + " IN "
// + " ( "
// + " SELECT \"LMSProgramID\" "
// + " FROM " + MiscConstants.DB_SCHEMA_NAME + ".\"ProgramApprover\" "
// + " WHERE \"ApproverUserId\" = {1} "
// + " ) ";
/////////////////////////////////////////////////////////////////////////
// MySQL
/////////////////////////////////////////////////////////////////////////
var sql = " SELECT * "
+ " FROM " + MiscConstants.DB_SCHEMA_NAME + ".ProgramEnrollment "
+ " WHERE ProgramEnrollmentID = {0} "
+ " AND LMSProgramID "
+ " IN "
+ " ( "
+ " SELECT LMSProgramID "
+ " FROM " + MiscConstants.DB_SCHEMA_NAME + ".ProgramApprover "
+ " WHERE ApproverUserId = {1} "
+ " ) ";
/////////////////////////////////////////////////////////////////////////
lvProgramEnrollment = null;
lvProgramEnrollment = await _dbContext.ProgramEnrollments
.FromSql(sql, programEnrollmentID, _userManager.GetUserId(User))
.Include(pe => pe.EnrollmentHistory)
.SingleOrDefaultAsync();
/////////////////////////////////////////////////////////////
// We already know that record exists from Step #1 so if we
// get a "Not Found" in Step #2, we know it's because the
// logged-in user is not authorized to edit (approve/deny)
// enrollment applications for this LMS Program.
/////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
return(Unauthorized());
}
////////////////////////////////////////////////////////////
// Retrieve the correct StatusTransition
////////////////////////////////////////////////////////////
var lvStatusTranstion = await _dbContext.StatusTransitions
.Where(st => st.TransitionCode == statusTransitionCode)
.AsNoTracking()
.SingleOrDefaultAsync();
////////////////////////////////////////////////////////////////
// Create EnrollmentHistory using the correct StatusTranistion
////////////////////////////////////////////////////////////////
var lvEnrollmentHistory = new EnrollmentHistory()
{
StatusTransitionID = lvStatusTranstion.StatusTransitionID,
ActorUserId = _userManager.GetUserId(User),
ActorRemarks = Input.Remarks,
DateCreated = DateTime.Now
};
////////////////////////////////////////////////////////////
// Instantiate EnrollmentHistory, if necessary
////////////////////////////////////////////////////////////
if (lvProgramEnrollment.EnrollmentHistory == null)
{
lvProgramEnrollment.EnrollmentHistory = new List <EnrollmentHistory>();
}
///////////////////////////////////////////////////////////////////
// Add newly created EnrollmentHistory with StatusTransition
// to ProgramEnrollment's EnrollmentHistory Collection
///////////////////////////////////////////////////////////////////
lvProgramEnrollment.EnrollmentHistory.Add(lvEnrollmentHistory);
/////////////////////////////////////////////////////////////////
// Update ProgramEnrollment Record with
// 1. EnrollmentStatus of "APPROVED"
// 2. ApproverUserId (logged-in user)
// 3. EnrollmentHistory (PENDING TO APPROVED)
/////////////////////////////////////////////////////////////////
lvProgramEnrollment.StatusCode = statusCode;
lvProgramEnrollment.ApproverUserId = _userManager.GetUserId(User);
_dbContext.ProgramEnrollments.Update(lvProgramEnrollment);
await _dbContext.SaveChangesAsync();
//////////////////////////////////////////////////////////////////////////////
// Retrieve 'User as Approver' for event logging
//////////////////////////////////////////////////////////////////////////////
ApplicationUser approver = await GetCurrentUserAsync();
//////////////////////////////////////////////////////////////////
// Determine EventType StatusCode
//////////////////////////////////////////////////////////////////
string eventTypeCode = null;
if (statusCode.Equals(StatusCodeConstants.APPROVED))
{
eventTypeCode = EventTypeCodeConstants.ENROLLMENT_APPROVED;
}
if (statusCode.Equals(StatusCodeConstants.DENIED))
{
eventTypeCode = EventTypeCodeConstants.ENROLLMENT_DENIED;
}
if (statusCode.Equals(StatusCodeConstants.REVOKED))
{
eventTypeCode = EventTypeCodeConstants.ENROLLMENT_REVOKED;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Log the ENROLLMENT <APPROVED || DENIED || REVOKED> event
/////////////////////////////////////////////////////////////////////////////////////////////
_eventLogService.LogEvent(eventTypeCode, approver, lvProgramEnrollment.ProgramEnrollmentID);
/////////////////////////////////////////////////////////////////////
// Send email notification to student, advising him/her of
// program enrollment status
/////////////////////////////////////////////////////////////////////
lvProgramEnrollment = null;
lvProgramEnrollment = await _dbContext.ProgramEnrollments
.Where(pe => pe.ProgramEnrollmentID == programEnrollmentID)
.Include(pe => pe.LMSProgram)
.Include(pe => pe.Student)
.Include(pe => pe.EnrollmentStatus)
.AsNoTracking()
.SingleOrDefaultAsync();
ApplicationUser student = lvProgramEnrollment.Student;
string email = student.Email;
string subject = lvProgramEnrollment.LMSProgram.LongName
+ " Enrollment Status";
string message = "Your request to enroll in the "
+ lvProgramEnrollment.LMSProgram.LongName
+ " has been "
+ lvProgramEnrollment.EnrollmentStatus.StatusLabel
+ ".";
if (StatusCodeConstants.APPROVED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
message += "You will receive an additional email from the GSA Learning Academy "
+ "to finish setting up your account in the GSA Learning Academy "
+ "and begin the training program";
}
if (StatusCodeConstants.DENIED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
string referrer = Request.Headers["Referer"];
// TODO: Switch to a more professional way of doing this!
int end = referrer.IndexOf("Approvals"); // TEMPORARY!!
string baseUrl = referrer.Substring(0, end);
var studentLoginPath = baseUrl + "Account/Login";
message += " <a href='" + studentLoginPath + "'>Log-in</a> "
+ "to the training registration system for more information "
+ "regarding the denial and request to reenroll in the program..";
}
if (StatusCodeConstants.REVOKED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
string referrer = Request.Headers["Referer"];
// TODO: Switch to a more professional way of doing this!
int end = referrer.IndexOf("Approvals"); // TEMPORARY!!
string baseUrl = referrer.Substring(0, end);
var studentLoginPath = baseUrl + "Account/Login";
message += " <a href='" + studentLoginPath + "'>Log-in</a> "
+ "to the training registration system for more information "
+ "regarding the revocation and request to reenroll in the program..";
}
await _emailSender.SendEmailAsync(email, subject, message);
/////////////////////////////////////////////////////////////////
// Redirect to Approval Index Page
/////////////////////////////////////////////////////////////////
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync(int programEnrollmentID, string statusCode, string statusTransitionCode)
{
Console.WriteLine("Approvals.Review.OnPostAsync(): BEGIN");
Console.WriteLine("id: " + programEnrollmentID);
Console.WriteLine("Remarks: " + Input.Remarks);
////////////////////////////////////////////////////////////
// Step #1:
// Check to see if records exists
////////////////////////////////////////////////////////////
var lvProgramEnrollment = await _dbContext.ProgramEnrollments
.Where(pe => pe.ProgramEnrollmentID == programEnrollmentID)
.AsNoTracking()
.SingleOrDefaultAsync();
////////////////////////////////////////////////////////////
// Return "Not Found" if record doesn't exist
////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
Console.WriteLine("ProgramEnrollment NOT FOUND in Step #1");
return(NotFound());
}
////////////////////////////////////////////////////////////
// Step #2:
// Now that record exists, make sure that the logged-in user
// is authorized to edit (approver/deny) enrollment
// applications for this particular LMS Program.
////////////////////////////////////////////////////////////
var sql = " SELECT * "
+ " FROM " + MiscConstants.DB_SCHEMA_NAME + ".\"ProgramEnrollment\" "
+ " WHERE \"ProgramEnrollmentID\" = {0} "
+ " AND \"LMSProgramID\" "
+ " IN "
+ " ( "
+ " SELECT \"LMSProgramID\" "
+ " FROM " + MiscConstants.DB_SCHEMA_NAME + ".\"ProgramApprover\" "
+ " WHERE \"ApproverUserId\" = {1} "
+ " ) ";
lvProgramEnrollment = null;
lvProgramEnrollment = await _dbContext.ProgramEnrollments
.FromSql(sql, programEnrollmentID, _userManager.GetUserId(User))
.Include(pe => pe.EnrollmentHistory)
.SingleOrDefaultAsync();
/////////////////////////////////////////////////////////////
// We already know that record exists from Step #1 so if we
// get a "Not Found" in Step #2, we know it's because the
// logged-in user is not authorized to edit (approve/deny)
// enrollment applications for this LMS Program.
/////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
return(Unauthorized());
}
////////////////////////////////////////////////////////////
// Retrieve the correct StatusTransition
////////////////////////////////////////////////////////////
var lvStatusTranstion = await _dbContext.StatusTransitions
.Where(st => st.TransitionCode == statusTransitionCode)
.AsNoTracking()
.SingleOrDefaultAsync();
////////////////////////////////////////////////////////////////
// Create EnrollmentHistory using the correct StatusTranistion
////////////////////////////////////////////////////////////////
var lvEnrollmentHistory = new EnrollmentHistory()
{
StatusTransitionID = lvStatusTranstion.StatusTransitionID,
ActorUserId = _userManager.GetUserId(User),
ActorRemarks = Input.Remarks,
DateCreated = DateTime.Now
};
////////////////////////////////////////////////////////////
// Instantiate EnrollmentHistory, if necessary
////////////////////////////////////////////////////////////
if (lvProgramEnrollment.EnrollmentHistory == null)
{
lvProgramEnrollment.EnrollmentHistory = new List <EnrollmentHistory>();
}
///////////////////////////////////////////////////////////////////
// Add newly created EnrollmentHistory with StatusTransition
// to ProgramEnrollment's EnrollmentHistory Collection
///////////////////////////////////////////////////////////////////
lvProgramEnrollment.EnrollmentHistory.Add(lvEnrollmentHistory);
/////////////////////////////////////////////////////////////////
// Update ProgramEnrollment Record with
// 1. EnrollmentStatus of "APPROVED"
// 2. ApproverUserId (logged-in user)
// 3. EnrollmentHistory (PENDING TO APPROVED)
/////////////////////////////////////////////////////////////////
lvProgramEnrollment.StatusCode = statusCode;
lvProgramEnrollment.ApproverUserId = _userManager.GetUserId(User);
_dbContext.ProgramEnrollments.Update(lvProgramEnrollment);
await _dbContext.SaveChangesAsync();
/////////////////////////////////////////////////////////////////////
// Send email notification to student, advising him/her of
// program enrollment status
/////////////////////////////////////////////////////////////////////
lvProgramEnrollment = null;
lvProgramEnrollment = await _dbContext.ProgramEnrollments
.Where(pe => pe.ProgramEnrollmentID == programEnrollmentID)
.Include(pe => pe.LMSProgram)
.Include(pe => pe.Student)
.Include(pe => pe.EnrollmentStatus)
.AsNoTracking()
.SingleOrDefaultAsync();
ApplicationUser student = lvProgramEnrollment.Student;
string email = student.Email;
string subject = lvProgramEnrollment.LMSProgram.LongName
+ " Enrollment Status";
string message = "Your request to enroll in the "
+ lvProgramEnrollment.LMSProgram.LongName
+ " has been "
+ lvProgramEnrollment.EnrollmentStatus.StatusLabel
+ ".";
if (StatusCodeConstants.DENIED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
string referrer = Request.Headers["Referer"];
// TODO: Switch to a more professional way of doing this!
int end = referrer.IndexOf("Approvals"); // TEMPORARY!!
string baseUrl = referrer.Substring(0, end);
Console.WriteLine("baseUrl: ");
Console.WriteLine(baseUrl);
var studentLoginPath = baseUrl + "Account/Login";
Console.WriteLine("studentLoginPath: ");
Console.WriteLine(studentLoginPath);
message += " <a href='" + studentLoginPath + "'>Log-in</a> "
+ "to the training registration system for more information regarding the denial.";
}
await _emailSender.SendEmailAsync(email, subject, message);
/////////////////////////////////////////////////////////////////
// Redirect to Approval Index Page
/////////////////////////////////////////////////////////////////
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync(int programEnrollmentID, string statusCode, string statusTransitionCode)
{
////////////////////////////////////////////////////////////
// Step #1:
// Check to see if records exists
////////////////////////////////////////////////////////////
var lvProgramEnrollment = await _dbContext.ProgramEnrollments
.Where(pe => pe.ProgramEnrollmentID == programEnrollmentID)
.AsNoTracking()
.SingleOrDefaultAsync();
////////////////////////////////////////////////////////////
// Return "Not Found" if record doesn't exist
////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
_logger.LogInformation("[Approvals][ReviewModel][OnPostAsync] => ProgramEnrollment NOT FOUND ProgramEnrollmentID '" + programEnrollmentID + "'");
return(NotFound());
}
////////////////////////////////////////////////////////////
// Step #2:
// Now that record exists, make sure that the logged-in user
// is authorized to edit (approver/deny) enrollment
// applications for this particular LMS Program.
//////////////////////////////////////////////////////////////////////////
// PostgreSQL
/////////////////////////////////////////////////////////////////////////
// var sql = " SELECT * "
// + " FROM " + MiscConstants.DB_SCHEMA_NAME + ".\"ProgramEnrollment\" "
// + " WHERE \"ProgramEnrollmentID\" = {0} "
// + " AND \"LMSProgramID\" "
// + " IN "
// + " ( "
// + " SELECT \"LMSProgramID\" "
// + " FROM " + MiscConstants.DB_SCHEMA_NAME + ".\"ProgramApprover\" "
// + " WHERE \"ApproverUserId\" = {1} "
// + " ) ";
/////////////////////////////////////////////////////////////////////////
// MySQL
/////////////////////////////////////////////////////////////////////////
var sql = " SELECT * "
+ " FROM " + MiscConstants.DB_SCHEMA_NAME + ".ProgramEnrollment "
+ " WHERE ProgramEnrollmentID = {0} "
+ " AND LMSProgramID "
+ " IN "
+ " ( "
+ " SELECT LMSProgramID "
+ " FROM " + MiscConstants.DB_SCHEMA_NAME + ".ProgramApprover "
+ " WHERE ApproverUserId = {1} "
+ " ) ";
/////////////////////////////////////////////////////////////////////////
lvProgramEnrollment = null;
lvProgramEnrollment = await _dbContext.ProgramEnrollments
.FromSqlRaw(sql, programEnrollmentID, _userManager.GetUserId(User))
.Include(pe => pe.LMSProgram)
.Include(pe => pe.EnrollmentHistory)
.SingleOrDefaultAsync();
/////////////////////////////////////////////////////////////
// We already know that record exists from Step #1 so if we
// get a "Not Found" in Step #2, we know it's because the
// logged-in user is not authorized to edit (approve/deny)
// enrollment applications for this LMS Program.
/////////////////////////////////////////////////////////////
if (lvProgramEnrollment == null)
{
return(Unauthorized());
}
////////////////////////////////////////////////////////////
// Retrieve the correct StatusTransition
////////////////////////////////////////////////////////////
var lvStatusTranstion = await _dbContext.StatusTransitions
.Where(st => st.TransitionCode == statusTransitionCode)
.AsNoTracking()
.SingleOrDefaultAsync();
////////////////////////////////////////////////////////////////
// Create EnrollmentHistory using the correct StatusTranistion
////////////////////////////////////////////////////////////////
var lvEnrollmentHistory = new EnrollmentHistory()
{
StatusTransitionID = lvStatusTranstion.StatusTransitionID,
ActorUserId = _userManager.GetUserId(User),
ActorRemarks = Input.Remarks,
DateCreated = DateTime.Now
};
////////////////////////////////////////////////////////////
// Instantiate EnrollmentHistory, if necessary
////////////////////////////////////////////////////////////
if (lvProgramEnrollment.EnrollmentHistory == null)
{
lvProgramEnrollment.EnrollmentHistory = new List <EnrollmentHistory>();
}
///////////////////////////////////////////////////////////////////
// Add newly created EnrollmentHistory with StatusTransition
// to ProgramEnrollment's EnrollmentHistory Collection
///////////////////////////////////////////////////////////////////
lvProgramEnrollment.EnrollmentHistory.Add(lvEnrollmentHistory);
/////////////////////////////////////////////////////////////////
// Update ProgramEnrollment Record with
// 1. EnrollmentStatus of "APPROVED"
// 2. ApproverUserId (logged-in user)
// 3. EnrollmentHistory (PENDING TO APPROVED)
/////////////////////////////////////////////////////////////////
string logSnippet = new StringBuilder("[")
.Append(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss"))
.Append("][")
.Append(_userManager.GetUserId(User))
.Append("][Approver][Review][HttpPost] => ")
.ToString();
Console.WriteLine(logSnippet + $"(lvProgramEnrollment.LMSProgram == null)....: {lvProgramEnrollment.LMSProgram == null}");
Console.WriteLine(logSnippet + $"(lvProgramEnrollment.LMSProgram.ShortName)..: {lvProgramEnrollment.LMSProgram.ShortName}");
Console.WriteLine(logSnippet + $"(lvProgramEnrollment.LMSProgram.ExpiryDays).: {lvProgramEnrollment.LMSProgram.ExpiryDays}");
lvProgramEnrollment.StatusCode = statusCode;
lvProgramEnrollment.DateLastUpdated = DateTime.Now;
if (lvProgramEnrollment.StatusCode.Equals(StatusCodeConstants.APPROVED))
{
lvProgramEnrollment.DateExpired = lvProgramEnrollment.DateLastUpdated.AddDays(lvProgramEnrollment.LMSProgram.ExpiryDays);
}
else if (lvProgramEnrollment.StatusCode.Equals(StatusCodeConstants.REVOKED))
{
lvProgramEnrollment.DateExpired = DateTime.Now;
}
else
{
lvProgramEnrollment.DateExpired = null;
}
Console.WriteLine(logSnippet + $"(lvProgramEnrollment.DateLastUpdated)..: {lvProgramEnrollment.DateLastUpdated}");
Console.WriteLine(logSnippet + $"(lvProgramEnrollment.StatusCode).......: {lvProgramEnrollment.StatusCode}");
Console.WriteLine(logSnippet + $"(lvProgramEnrollment.DateExpired)......: {lvProgramEnrollment.DateExpired}");
lvProgramEnrollment.ApproverUserId = _userManager.GetUserId(User);
_dbContext.ProgramEnrollments.Update(lvProgramEnrollment);
await _dbContext.SaveChangesAsync();
//////////////////////////////////////////////////////////////////////////////
// Retrieve 'User as Approver' for event logging
//////////////////////////////////////////////////////////////////////////////
ApplicationUser approver = await GetCurrentUserAsync();
//////////////////////////////////////////////////////////////////
// Determine EventType StatusCode
//////////////////////////////////////////////////////////////////
string eventTypeCode = null;
if (statusCode.Equals(StatusCodeConstants.APPROVED))
{
eventTypeCode = EventTypeCodeConstants.ENROLLMENT_APPROVED;
}
if (statusCode.Equals(StatusCodeConstants.DENIED))
{
eventTypeCode = EventTypeCodeConstants.ENROLLMENT_DENIED;
}
if (statusCode.Equals(StatusCodeConstants.REVOKED))
{
eventTypeCode = EventTypeCodeConstants.ENROLLMENT_REVOKED;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Log the ENROLLMENT <APPROVED || DENIED || REVOKED> event
/////////////////////////////////////////////////////////////////////////////////////////////
//_eventLogService.LogEvent(eventTypeCode, approver, lvProgramEnrollment.ProgramEnrollmentID);
_eventLogService.LogEvent(eventTypeCode, approver, lvProgramEnrollment);
/////////////////////////////////////////////////////////////////////
// Send email notification to student, advising him/her of
// program enrollment status
/////////////////////////////////////////////////////////////////////
lvProgramEnrollment = null;
lvProgramEnrollment = await _dbContext.ProgramEnrollments
.Where(pe => pe.ProgramEnrollmentID == programEnrollmentID)
.Include(pe => pe.LMSProgram)
.Include(pe => pe.Student)
.Include(pe => pe.EnrollmentStatus)
.AsNoTracking()
.SingleOrDefaultAsync();
ApplicationUser student = lvProgramEnrollment.Student;
string email = student.Email;
string subject = lvProgramEnrollment.LMSProgram.LongName
+ " Enrollment Status";
string message = "Your request to enroll in the "
+ lvProgramEnrollment.LMSProgram.LongName
+ " has been "
+ lvProgramEnrollment.EnrollmentStatus.StatusLabel
+ ".";
////////////////////////////////////////////////////////////////
// SET BANNER THAT WILL BE DISPLAYED ON THE APPROVER INDEX PAGE
////////////////////////////////////////////////////////////////
StringBuilder bannerMsg = new StringBuilder();
bannerMsg.Append("Request by ");
bannerMsg.Append(lvProgramEnrollment.Student.FullName);
bannerMsg.Append(" to enroll in ");
bannerMsg.Append(lvProgramEnrollment.LMSProgram.LongName);
bannerMsg.Append(" has been ");
bannerMsg.Append(lvProgramEnrollment.EnrollmentStatus.StatusLabel);
bannerMsg.Append(".");
HttpContext.Session.SetString(ApproverConstants.STATUS_CHANGE_MODAL_TITLE, lvProgramEnrollment.EnrollmentStatus.StatusCode);
HttpContext.Session.SetString(ApproverConstants.STATUS_CHANGE_MODAL_TEXT, bannerMsg.ToString());
////////////////////////////////////////////////////////////////
// BUILD EMAIL MESSAGE TO STUDENT
////////////////////////////////////////////////////////////////
if (StatusCodeConstants.APPROVED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
message += "You will receive an additional email from the GSA Learning Academy "
+ "to finish setting up your account in the GSA Learning Academy "
+ "and begin the training program";
}
if (StatusCodeConstants.DENIED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
message += " <a href='" + MiscConstants.LOGIN_URL + "'>Log-in</a> "
+ "to the training registration system for more information "
+ "regarding the denial and request to reenroll in the program..";
}
if (StatusCodeConstants.REVOKED.Equals(lvProgramEnrollment.EnrollmentStatus.StatusCode))
{
message += " <a href='" + MiscConstants.LOGIN_URL + "'>Log-in</a> "
+ "to the training registration system for more information "
+ "regarding the revocation and request to reenroll in the program..";
}
await _emailSender.SendEmailAsync(email, subject, message);
/////////////////////////////////////////////////////////////////
// Redirect to Approval Index Page
/////////////////////////////////////////////////////////////////
return(RedirectToPage("./Index"));
}
