public StatusTransition RetrieveOrgStatusTranstion(int qmsStatusTransId)
{
QmsStatusTrans statusTrans = context.QmsStatusTrans.AsNoTracking().Where(s => s.StatusTransId == qmsStatusTransId && s.DeletedAt == null).Include(s => s.ToStatus).Include(s => s.FromStatus).SingleOrDefault();
QmsStatus fromStatus = statusTrans.FromStatus;
QmsStatus toStatus = statusTrans.ToStatus;
StatusTransition retval = new StatusTransition(statusTrans, fromStatus, toStatus);
return(retval);
}
/// <summary>
/// Creates balance report.
/// </summary>
public List <PeriodGroup> CreateReport(GroupingPeriod groupBy, bool ignorePostponed)
{
// Input data:
// +) revisions (filter for bugs)
// +) interval duration (by day, by week, by month, by quater, by year)
// +) additional options (e.g. how to treat Postponed)
// Resulting groups
List <PeriodGroup> groups = new List <PeriodGroup>();
// Get bugs for specified filter
Bug[] bugs = m_provider.GetBugs();
// Process all bugs
foreach (Bug bug in bugs)
{
// Get all revisions for selected bugs (they should be sorted)
Revision[] revisions = m_provider.GetRevisions(bug.Number);
Revision prevRevision = null;
// Go through revisions of one bug
foreach (Revision revision in revisions)
{
// Compare current and previous revision
StatusTransition trans = GetStatusTransition(prevRevision, revision);
// When combination of states corresponds to state transition
if (trans != StatusTransition.None)
{
// Get record for period correspondent to the date of current revision
PeriodGroup group = GetGroup(groups, groupBy, revision);
// Update correspondent values
group.Added += trans == StatusTransition.Added ? 1 : 0;
group.Removed += trans == StatusTransition.Removed ? 1 : 0;
group.Postponed += trans == StatusTransition.Postponed ? 1 : 0;
group.Reactivated += trans == StatusTransition.Reactivated ? 1 : 0;
}
// Remember current revision
prevRevision = revision;
}
}
// Sort groups by index because they go in arbitrary order
groups.Sort((x, y) => x.Interval - y.Interval);
// Make groups go without gaps
UnsparseGroups(groups, groupBy);
// Return report
return(groups);
}
private static async Task EnsureStatusTransition(ApplicationDbContext dbContext, string fromStatusCode, string toStatusCode,
string transitionCode, string transitionLabel)
{
Console.WriteLine("DataSeed.EnsureStatusTransition: BEGIN");
var statusTransition = await dbContext.StatusTransitions.FirstOrDefaultAsync(st => st.FromStatusCode == fromStatusCode && st.ToStatusCode == toStatusCode);
if (statusTransition == null)
{
statusTransition = new StatusTransition
{
FromStatusCode = fromStatusCode,
ToStatusCode = toStatusCode,
TransitionCode = transitionCode,
TransitionLabel = transitionLabel
};
dbContext.StatusTransitions.Add(statusTransition);
await dbContext.SaveChangesAsync();
}
Console.WriteLine("DataSeed.EnsureStatusTransition: END");
}
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"));
}
internal int ExecuteUpdates(CorrectiveAction correctiveAction, User submittedBy, string history)
{
submitter = submittedBy;
this.entity = correctiveAction;
int retval = entity.Id;
isNewTicket = retval == 0;
routesToRBC = determineIfTicketRoutesToRBC(); // if submitted by PPRM this would need to be skipped
StatusTransition action = referenceRepository.RetrieveOrgStatusTranstion(correctiveAction.ActionId);
string actionToStatus = action.ToStatus.StatusCode;
this.entity.StatusId = action.ToStatus.StatusId;
if (isNewTicket)
{
this.entity.CreatedAt = DateTime.Now;
this.entity.CreatedByUserId = submitter.UserId;
this.entity.CreatedAtOrgId = submitter.OrgId.Value;
this.entity.AssignedToOrgId = submitter.OrgId.Value;
QmsCorrectiveactionrequest initialCar = correctiveAction.QmsCorrectiveActionRequest;
correctiveActionRepository.context.Add(initialCar);
correctiveActionRepository.context.SaveChanges();
retval = initialCar.Id;
this.entity.Id = initialCar.Id;
}
else
{
this.entity.UpdatedAt = DateTime.Now;
}
if (actionToStatus == StatusType.UNASSIGNED)
{
ActionDescription = string.Format("{0} submitted Corrective Action for resolution<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Submitted;
SubmitForResolution();
}
else if (actionToStatus == StatusType.ASSIGNED)
{
ActionDescription = string.Format("{0} assigned Corrective Action<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Assigned;
AssignToUser(entity);
}
else if (actionToStatus == StatusType.CLOSED)
{
ActionDescription = string.Format("{0} closed Corrective Action<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Closed;
Close(entity);
}
else if (actionToStatus == StatusType.CLOSED_ACTION_COMPLETED)
{
ActionDescription = string.Format("{0} completed Corrective Action<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Closed;
CloseActionCompleted(entity);
}
else if (actionToStatus == StatusType.DRAFT)
{
if (isNewTicket)
{
ActionDescription = string.Format("{0} created Corrective Action", submitter.DisplayName);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Created;
SaveAsDraft(entity);
}
else
{
ActionDescription = string.Format("{0} withdrew Corrective Action<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Withdrawn;
WithdrawItem(entity);
}
}
else if (actionToStatus == StatusType.PENDING_REVIEW)
{
ActionDescription = string.Format("{0} submitted Corrective Action for review<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_PendingReview;
SubmitForReview(entity);
}
else if (actionToStatus == StatusType.RETURNED)
{
ActionDescription = string.Format("{0} returned Corrective Action to originator<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Returned;
Return(entity);
}
else if (actionToStatus == StatusType.REROUTED)
{
ActionDescription = string.Format("{0} rerouted Corrective Action<br/>{1}", submitter.DisplayName, history);
correctiveActionService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = CorrectiveActionNotificationType.CA_Rerouted;
Reroute(entity);
}
else
{
throw new InvalidStatusTypeException(actionToStatus + " is not a valid StatusType.");
}
QmsCorrectiveactionrequest car = this.entity.QmsCorrectiveActionRequest;
correctiveActionRepository.Update(car);
saveErrors(this.entity.ErrorTypes, retval, isNewTicket);
correctiveActionRepository.context.SaveChanges();
return(retval);
}
internal int ExecuteUpdates(DataError ehriError, User submittedBy, string history)
{
submitter = submittedBy;
entity = ehriError;
StatusTransition action = referenceRepository.RetrieveOrgStatusTranstion(ehriError.OrgStatusTransId);
string actionStatus = action.ToStatus.StatusCode;
entity.StatusId = action.ToStatus.StatusId;
entity.UpdatedAt = DateTime.Now;
if(actionStatus == StatusType.UNASSIGNED)
{
ActionDescription = string.Format("{0} submitted error for resolution<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_Submitted;
SubmitForResolution();
}
else if(actionStatus == StatusType.ASSIGNED)
{
ActionDescription = string.Format("{0} assigned error<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_Assigned;
AssignToUser(entity);
}
else if(actionStatus == StatusType.CLOSED)
{
ActionDescription = string.Format("{0} closed error<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_Closed;
Close(entity);
}
else if(actionStatus == StatusType.CLOSED_ACTION_COMPLETED)
{
ActionDescription = string.Format("{0} completed error<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_Closed;
CloseActionCompleted(entity);
}
else if(actionStatus == StatusType.PENDING_REVIEW)
{
ActionDescription = string.Format("{0} submitted error for review<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_PendingReview;
SubmitForReview(entity);
}
else if(actionStatus == StatusType.RETURNED)
{
ActionDescription = string.Format("{0} returned error to specialist<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_Returned;
Return(entity);
}
else if (actionStatus == StatusType.CLOSED_CONVERT_TO_CORR_ACTION)
{
ActionDescription = string.Format("{0} converted to corrective action<br/>{1}",submitter.DisplayName,history);
dataErrorService.addHistory(this.entity, submitter, ActionDescription);
NotificationEventType = EhriErrorNotificationType.EHRI_Closed;
createCorrectiveAction(submittedBy);
}
QmsDataerror error = entity.QmsDataError();
dataErrorRepository.Update(error);
dataErrorRepository.context.SaveChanges();
return ehriError.Id;
}
