507 lines
19 KiB
C#
507 lines
19 KiB
C#
using Fab2ApprovalSystem.DMO;
|
|
using Fab2ApprovalSystem.Models;
|
|
using Fab2ApprovalSystem.ViewModels;
|
|
using Kendo.Mvc.UI;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Web;
|
|
using System.Web.Mvc;
|
|
using Kendo.Mvc.Extensions;
|
|
using Fab2ApprovalSystem.Misc;
|
|
using System.Configuration;
|
|
|
|
namespace Fab2ApprovalSystem.Controllers
|
|
{
|
|
[Authorize]
|
|
[SessionExpireFilter]
|
|
public class TrainingController : Controller
|
|
{
|
|
UserAccountDMO userDMO = new UserAccountDMO();
|
|
AdminDMO adminDMO = new AdminDMO();
|
|
TrainingDMO trainingDMO = new TrainingDMO();
|
|
ECN_DMO ecnDMO = new ECN_DMO();
|
|
// GET: Training
|
|
public ActionResult Index()
|
|
{
|
|
return View();
|
|
}
|
|
//public int Create(int ecnId, List<int> groupIds)
|
|
public int Create(int ecnId)
|
|
{
|
|
ECN_DMO ecnDMO = new ECN_DMO();
|
|
|
|
//Delete old training if exists
|
|
int oldTrainingId = trainingDMO.GetTrainingId(ecnId);
|
|
if (oldTrainingId != null && oldTrainingId != 0)
|
|
{
|
|
trainingDMO.DeleteTraining(oldTrainingId);
|
|
}
|
|
|
|
|
|
int trainingId = trainingDMO.Create(ecnId);
|
|
List<int> TrainingGroups = new List<int>();
|
|
TrainingGroups = trainingDMO.GetECNAssignedTrainingGroups(ecnId);
|
|
string ECNTitle = ecnDMO.GetECN(ecnId).Title;
|
|
List<int> Trainees = new List<int>();
|
|
foreach (var group in TrainingGroups)
|
|
{
|
|
Trainees.AddRange(trainingDMO.GetTrainees(group));
|
|
}
|
|
Trainees = (from a in Trainees select a).Distinct().ToList();
|
|
|
|
foreach (var trainee in Trainees)
|
|
{
|
|
int assignmentId = trainingDMO.CreateAssignment(trainingId, trainee);
|
|
NotifyTrainee(trainee, assignmentId, ecnId, ECNTitle);
|
|
}
|
|
|
|
|
|
return trainingId;
|
|
}
|
|
public ActionResult AddUserToTrainingAdHoc(int trainingId, int traineeId, int ecnId)
|
|
{
|
|
//Get ECN
|
|
ECN ecn = ecnDMO.GetECN(ecnId);
|
|
|
|
//Get User
|
|
LoginModel user = userDMO.GetUserByID(traineeId);
|
|
|
|
//Get Training
|
|
Training training = trainingDMO.GetTraining(trainingId);
|
|
if (ecn != null)
|
|
{
|
|
if(user != null)
|
|
{
|
|
if(training != null)
|
|
{
|
|
if(training.CompletedDate == null && training.DeletedDate == null)
|
|
{
|
|
//Add user to training
|
|
int assignmentId = trainingDMO.CreateAssignment(trainingId, traineeId);
|
|
NotifyTrainee(traineeId, assignmentId, ecnId, ecn.Title);
|
|
return Content("Success");
|
|
}
|
|
else
|
|
{
|
|
return Content("Selected training has either been deleted or has completed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Content("Invalid training id.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Content("invalid userId");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Content("ECN invalid");
|
|
}
|
|
}
|
|
public ActionResult DeleteTrainingByECN(int ECNNumber)
|
|
{
|
|
int trainingId = trainingDMO.GetTrainingId(ECNNumber);
|
|
if (trainingId != null && trainingId != 0)
|
|
{
|
|
trainingDMO.DeleteTraining(trainingId);
|
|
}
|
|
return RedirectToAction("ViewTrainings");
|
|
}
|
|
|
|
public ActionResult DeleteTrainingByID(int trainingId)
|
|
{
|
|
if (trainingId != null && trainingId != 0)
|
|
{
|
|
trainingDMO.DeleteTraining(trainingId);
|
|
}
|
|
return RedirectToAction("ViewTrainings");
|
|
}
|
|
public void NotifyTrainee(int userId, int assignmentId, int ecnId, string title)
|
|
{
|
|
|
|
try
|
|
{
|
|
string emailSentList = "";
|
|
//ECN ecn = ecnDMO.GetECN(ecnNumber);
|
|
//List<string> emailIst = ldDMO.GetApproverEmailList(@issueID, currentStep).Distinct().ToList();
|
|
string recipient = userDMO.GetUserEmailByID(userId.ToString());
|
|
|
|
string emailTemplate = "ECNTrainingAssigned.txt";
|
|
string userEmail = string.Empty;
|
|
string subject = string.Empty;
|
|
string senderName = "ECN Training";
|
|
|
|
subject = "ECN# " + ecnId + " - Training Assignment Notice - " + title;
|
|
|
|
EmailNotification en = new EmailNotification(subject, ConfigurationManager.AppSettings["EmailTemplatesPath"]);
|
|
//string emailparams = "";
|
|
userEmail = recipient;
|
|
string[] emailparams = new string[4];
|
|
emailparams[0] = assignmentId.ToString();
|
|
emailparams[1] = ecnId.ToString();
|
|
emailparams[2] = GlobalVars.hostURL;
|
|
//#if(DEBUG)
|
|
//string SenderEmail = "MesaFabApproval@infineon.com";
|
|
//userEmail = "jonathan.ouellette@infineon.com";
|
|
//#endif
|
|
|
|
en.SendNotificationEmail(emailTemplate, GlobalVars.SENDER_EMAIL, senderName, userEmail, null, subject, emailparams);
|
|
//en.SendNotificationEmail(emailTemplate, SenderEmail, senderName, userEmail, null, subject, emailparams);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
string detailedException = "";
|
|
try
|
|
{
|
|
detailedException = e.InnerException.ToString();
|
|
}
|
|
catch
|
|
{
|
|
detailedException = e.Message;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
public ActionResult ViewTrainingPartial(int trainingID, int userID)
|
|
{
|
|
List<TrainingAssignment> TrainingData = trainingDMO.GetTrainingAssignmentsByUser(trainingID, userID);
|
|
if (trainingID > 0)
|
|
{
|
|
ViewBag.ECNNumber = trainingDMO.GetTraining(trainingID).ECN;
|
|
}
|
|
return PartialView(TrainingData);
|
|
}
|
|
public ActionResult ViewTrainingDocsPartial(int trainingAssignmentId)
|
|
{
|
|
ViewBag.trainingAssignmentId = trainingAssignmentId;
|
|
//IEnumerable<TrainingDocAck> attachments = ecnDMO.GetECNAttachments(ecnNumber);
|
|
IEnumerable<TrainingDocAck> attachments = trainingDMO.GetAssignedDocs(trainingAssignmentId);
|
|
return PartialView(attachments);
|
|
}
|
|
public ActionResult AcknowledgeDocument(int trainingAssignmentID, int trainingDocAckID)
|
|
{
|
|
//Check to see if acknowledgement is valid(Security Feature to protect data integrity)
|
|
if (trainingDMO.CheckValidDocAck(trainingDocAckID))
|
|
{
|
|
trainingDMO.AcknowledgeDocument(trainingDocAckID);
|
|
bool isFinishedTrainingAssignment = trainingDMO.CheckTrainingAssignmentStatus(trainingAssignmentID);
|
|
|
|
if (isFinishedTrainingAssignment)
|
|
{
|
|
try
|
|
{
|
|
trainingDMO.UpdateAssignmentStatus(trainingAssignmentID);
|
|
bool isFinishedTraining = trainingDMO.CheckTrainingStatus(trainingAssignmentID);
|
|
if (isFinishedTraining)
|
|
{
|
|
int TrainingID = trainingDMO.GetTrainingIdByAssignment(trainingAssignmentID);
|
|
trainingDMO.UpdateTrainingStatus(TrainingID);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
string exception = e.ToString();
|
|
return Content(exception);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
return Content("Marked Succesfully.");
|
|
}
|
|
public ActionResult AcknowledgeReviewNoDocuments(int trainingAssignmentID)
|
|
{
|
|
try
|
|
{
|
|
trainingDMO.UpdateAssignmentStatus(trainingAssignmentID);
|
|
bool isFinishedTraining = trainingDMO.CheckTrainingStatus(trainingAssignmentID);
|
|
if (isFinishedTraining)
|
|
{
|
|
int TrainingID = trainingDMO.GetTrainingIdByAssignment(trainingAssignmentID);
|
|
trainingDMO.UpdateTrainingStatus(TrainingID);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
string exception = e.ToString();
|
|
return Content(exception, "application/json");
|
|
}
|
|
|
|
return Json(new { test = "Succesfully saved" });
|
|
}
|
|
//public ActionResult ViewTrainings()
|
|
//{
|
|
// IEnumerable<Training> trainings = trainingDMO.GetTrainings();
|
|
|
|
// return View(trainings);
|
|
//}
|
|
public ActionResult TrainingReports()
|
|
{
|
|
|
|
return View();
|
|
}
|
|
public ActionResult TrainingReportsView(int? filterType, string filterValue)
|
|
{
|
|
ViewBag.TrainingGroups = adminDMO.GetTrainingGroups();
|
|
IEnumerable<Training> trainingList = trainingDMO.GetAllTrainings();
|
|
//Group Filter
|
|
if (filterType == 1 && filterValue != "")
|
|
{
|
|
ViewBag.GroupFilter = filterValue;
|
|
List<Training> filteredTraining = new List<Training>();
|
|
foreach (var item in trainingList)
|
|
{
|
|
List<int> assignedTrainingGroups = trainingDMO.GetECNAssignedTrainingGroups(item.ECN);
|
|
foreach (int id in assignedTrainingGroups)
|
|
{
|
|
if (filterValue == id.ToString())
|
|
{
|
|
filteredTraining.Add(item);
|
|
}
|
|
}
|
|
}
|
|
trainingList = filteredTraining;
|
|
return PartialView(trainingList);
|
|
}
|
|
//Status Filter
|
|
if (filterType == 2 && filterValue != "")
|
|
{
|
|
List<Training> filteredTraining = new List<Training>();
|
|
switch (filterValue)
|
|
{
|
|
case "1":
|
|
//Completed
|
|
filteredTraining = (from a in trainingList where a.Status == true && a.Deleted != true select a).ToList();
|
|
break;
|
|
case "2":
|
|
//In Progress
|
|
filteredTraining = (from a in trainingList where a.Status != true && a.Deleted != true select a).ToList();
|
|
break;
|
|
case "3":
|
|
//Cancelled
|
|
filteredTraining = (from a in trainingList where a.Deleted == true select a).ToList();
|
|
break;
|
|
}
|
|
trainingList = filteredTraining;
|
|
return PartialView(trainingList);
|
|
}
|
|
//Default return all.
|
|
else
|
|
{
|
|
return PartialView(trainingList);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
public ActionResult ViewTrainingAssignmentsReportView(int trainingID, string statusFilter, string groupFilter)
|
|
{
|
|
bool? trainingStatus = trainingDMO.GetTraining(trainingID).Status;
|
|
int ECNNumber = trainingDMO.GetTraining(trainingID).ECN;
|
|
string ECNTitle = ecnDMO.GetECN(ECNNumber).Title;
|
|
ViewBag.TrainingGroups = adminDMO.GetTrainingGroups();
|
|
ViewBag.TrainingStatus = trainingStatus;
|
|
ViewBag.ECNNumber = ECNNumber;
|
|
ViewBag.ECNTitle = ECNTitle;
|
|
ViewBag.trainingID = trainingID;
|
|
IEnumerable<TrainingAssignment> trainingAssignments = trainingDMO.GetAllTrainingAssignments(trainingID);
|
|
//Calculate Percent Complete:
|
|
float percentComplete = 0;
|
|
float assignmentCount = trainingAssignments.Count();
|
|
float totalCompleted = 0;
|
|
foreach (var assignment in trainingAssignments)
|
|
{
|
|
if (assignment.status == true)
|
|
{
|
|
totalCompleted++;
|
|
}
|
|
}
|
|
percentComplete = (totalCompleted / assignmentCount) * 100;
|
|
ViewBag.PercentComplete = percentComplete.ToString("0.00") + "%";
|
|
|
|
if (groupFilter != "" && groupFilter != null)
|
|
{
|
|
ViewBag.GroupFilter = groupFilter;
|
|
List<TrainingAssignment> groupFilteredTraining = new List<TrainingAssignment>();
|
|
List<int> groupMemberIds = trainingDMO.GetTrainees(Convert.ToInt32(groupFilter));
|
|
foreach (var assignment in trainingAssignments)
|
|
{
|
|
if(trainingDMO.isUserTrainingMember(Convert.ToInt32(groupFilter), assignment.UserID))
|
|
{
|
|
groupFilteredTraining.Add(assignment);
|
|
}
|
|
}
|
|
trainingAssignments = groupFilteredTraining;
|
|
|
|
}
|
|
if (statusFilter != "" && statusFilter != null)
|
|
{
|
|
List<TrainingAssignment> filteredTraining = new List<TrainingAssignment>();
|
|
switch (statusFilter)
|
|
{
|
|
|
|
case "1":
|
|
//Completed
|
|
filteredTraining = (from a in trainingAssignments where a.status == true && a.Deleted != true select a).ToList();
|
|
break;
|
|
case "2":
|
|
//In Progress
|
|
filteredTraining = (from a in trainingAssignments where a.status != true && a.Deleted != true select a).ToList();
|
|
break;
|
|
case "3":
|
|
//Cancelled
|
|
filteredTraining = (from a in trainingAssignments where a.Deleted == true select a).ToList();
|
|
break;
|
|
default:
|
|
filteredTraining = (from a in trainingAssignments select a).ToList();
|
|
break;
|
|
}
|
|
trainingAssignments = filteredTraining;
|
|
//return PartialView(trainingList);
|
|
}
|
|
|
|
return PartialView(trainingAssignments);
|
|
}
|
|
public ActionResult ViewTrainingAssignments(int trainingID)
|
|
{
|
|
bool? trainingStatus = trainingDMO.GetTraining(trainingID).Status;
|
|
int ECNNumber = trainingDMO.GetTraining(trainingID).ECN;
|
|
string ECNTitle = ecnDMO.GetECN(ECNNumber).Title;
|
|
ViewBag.TrainingStatus = trainingStatus;
|
|
ViewBag.ECNNumber = ECNNumber;
|
|
ViewBag.ECNTitle = ECNTitle;
|
|
ViewBag.TrainingId = trainingID;
|
|
ViewBag.AllUsers = userDMO.GetAllUsers();
|
|
IEnumerable<TrainingAssignment> trainingAssignments = trainingDMO.GetTrainingAssignments(trainingID);
|
|
|
|
return View(trainingAssignments);
|
|
}
|
|
/// <summary>
|
|
/// Method to return all the training assignments for a specified user
|
|
/// </summary>
|
|
/// <param name="userID"></param>
|
|
/// <returns></returns>
|
|
public ActionResult ViewMyTrainingAssignments()
|
|
{
|
|
int userID = (int)Session[GlobalVars.SESSION_USERID];
|
|
List<TrainingAssignment> assignments = trainingDMO.GetTrainingAssignmentsByUserID(userID);
|
|
List<ECNTrainingAssignments> ViewData = new List<ECNTrainingAssignments>();
|
|
foreach (var assignment in assignments)
|
|
{
|
|
Training training = trainingDMO.GetTraining(assignment.TrainingID);
|
|
if (training != null)
|
|
{
|
|
int ecnID = training.ECN;
|
|
ViewData.Add(new ECNTrainingAssignments
|
|
{
|
|
TrainingAssignmentID = assignment.ID,
|
|
ECN_ID = ecnID,
|
|
TrainingID = assignment.TrainingID,
|
|
DateAssigned = assignment.DateAssigned,
|
|
DateCompleted = assignment.DateCompleted,
|
|
Status = assignment.status
|
|
|
|
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
return View(ViewData);
|
|
}
|
|
/// <summary>
|
|
/// Method to return all assigned documents for a specified training assignment
|
|
/// </summary>
|
|
/// <param name="assignmentID"></param>
|
|
/// <returns></returns>
|
|
public ActionResult ViewMyTrainingAssignment(int assignmentID, int ECNNumber)
|
|
{
|
|
ViewBag.ECNNumber = ECNNumber;
|
|
ViewBag.AssignmentID = assignmentID;
|
|
ViewBag.IsCompleted = trainingDMO.GetAssignment(assignmentID).status;
|
|
return View(trainingDMO.GetAssignedDocs(assignmentID));
|
|
}
|
|
public ActionResult ViewTrainings()
|
|
{
|
|
IEnumerable<Training> AllTrainings = trainingDMO.GetTrainings();
|
|
return View(AllTrainings);
|
|
}
|
|
public ActionResult ViewAllTrainings()
|
|
{
|
|
|
|
return View();
|
|
}
|
|
public ActionResult DeleteAssignment(int assignmentId)
|
|
{
|
|
trainingDMO.DeleteTrainingAssignment(assignmentId);
|
|
trainingDMO.DeleteTrainingDocAck(assignmentId);
|
|
|
|
//Below checks and updates the training status
|
|
//TO-DO Put this in its own method.
|
|
bool isFinishedTrainingAssignment = trainingDMO.CheckTrainingAssignmentStatus(assignmentId);
|
|
|
|
if (isFinishedTrainingAssignment)
|
|
{
|
|
try
|
|
{
|
|
trainingDMO.UpdateAssignmentStatus(assignmentId);
|
|
bool isFinishedTraining = trainingDMO.CheckTrainingStatus(assignmentId);
|
|
if (isFinishedTraining)
|
|
{
|
|
int TrainingID = trainingDMO.GetTrainingIdByAssignment(assignmentId);
|
|
trainingDMO.UpdateTrainingStatus(TrainingID);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
string exception = e.ToString();
|
|
return Content(exception, "application/json");
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return Json(new { test = "Succesfully saved" });
|
|
}
|
|
public ActionResult ManuallyExecuteECNTraining(int ecnId)
|
|
{
|
|
if ((bool)Session[GlobalVars.IS_ADMIN])
|
|
{
|
|
//Get ECN
|
|
ECN ecn = ecnDMO.GetECN(ecnId);
|
|
if (ecn != null)
|
|
{
|
|
Create(ecnId);
|
|
return Content("Success");
|
|
}
|
|
else
|
|
{
|
|
return Content("Invalid ECN");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Content("Not Autthorized");
|
|
}
|
|
}
|
|
//public ActionResult ViewAllTraining()
|
|
//{
|
|
// return View();
|
|
//}
|
|
//public ActionResult GetTrainings([DataSourceRequest] DataSourceRequest request)
|
|
//{
|
|
|
|
// return Json();
|
|
//}
|
|
}
|
|
|
|
}
|