/////////////////////////////////////////////////////////////////
public ActionResult Edit(int?recordId)
{
if (recordId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
HseqApprovalRequest approvalRequest = db.HseqApprovalRequests.Find(recordId);
if (approvalRequest == null)
{
return(HttpNotFound());
}
//Ncr ncr = db.NcrRecords.Find(recordId);
HseqRecord hseqRecord = db.HseqRecords.Find(approvalRequest.HseqRecordID);
if (hseqRecord == null)
{
return(HttpNotFound());
}
//NcrVM ncrVM = new NcrVM();
DelegatableVM ncrVM = new DelegatableVM()
{
HseqRecord = hseqRecord,
HseqApprovalRequest = approvalRequest,
ApprovalOwners = db.HseqUsers
};
return(View(ncrVM));
}
public void AddHseqTaskRequest(HseqRecord record, HseqTask taskRequest, ApplicationDbContext db)
{
//if (record is Ncr)
//{
// Ncr ncr = (Ncr)record;
//HseqTask taskRequest = new HseqTask();
//taskRequest.Owner = db.HseqUsers.Find(ApproverID);
taskRequest.Owner = db.HseqUsers.Find(taskRequest.OwnerID);
taskRequest.Assignee = db.HseqUsers.Find(taskRequest.AssigneeID);
taskRequest.DateAssigned = DateTime.Now;
if (taskRequest.DueDate == null || taskRequest.DueDate < DateTime.Now.Subtract(TimeSpan.FromDays(1)))
{
taskRequest.DueDate = DateTime.Now.AddDays(14);
}
else
{
taskRequest.DueDate = taskRequest.DueDate;
}
if (taskRequest.Status == null)
{
taskRequest.Status = TaskStatus.NotStarted;
}
taskRequest.HseqRecordID = record.HseqRecordID;
record.Delegatables.Add(taskRequest);
//}
}
public HseqRecord PopulateRecordTypeDefaults(RecordType recordType, HseqRecord hseqRecord)
{
hseqRecord.EnteredBy = HttpContext.Current.User.Identity.Name;
hseqRecord.ReportedBy = currentUser.FirstName + " " + currentUser.LastName + " , " + currentUser.Department;
//Retrieve the Quality Coordinator from the custom file
//ViewBag.QualityCoordinator = ConfigurationManager.AppSettings.Get("QualityCoordinator");
if (recordType.Equals(RecordType.NCR))
{
hseqRecord.RecordType = RecordType.NCR;
}
else if (recordType.Equals(RecordType.FIS))
{
hseqRecord.RecordType = RecordType.FIS;
}
else if (recordType.Equals(RecordType.CAR))
{
hseqRecord.RecordType = RecordType.CAR;
}
else if (recordType.Equals(RecordType.PAR))
{
hseqRecord.RecordType = RecordType.PAR;
}
return(hseqRecord);
}
////////////////////////////////////////
public ActionResult LinkedItems()
{
string currentActiveView;
string recordId;
List <HseqRecord> linkedRecords = new List <HseqRecord>();
HseqRecord record = null;
if (DevExpressHelper.IsCallback)
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]))
{
currentActiveView = Request.Params["currentActiveView"];
}
if (!string.IsNullOrEmpty(Request.Params["recordId"]))
{
recordId = Request.Params["recordId"];
record = db.HseqRecords.Find(int.Parse(recordId));
linkedRecords = record.LinkedRecords.ToList();
ViewData["LinkedItems"] = record.LinkedRecords;
}
}
return(PartialView("_LinkedItemsPanel", linkedRecords));
}
public ActionResult CarGridViewLinked(CarVM carVM)
{
if (ModelState.IsValid)
{
try
{
if (carVM != null)
{
Car car = carVM.Car;
car.CreatedBy = _RecordService.GetCurrentUser().FullName;
db.HseqRecords.Add(car);
db.SaveChanges();
HseqRecord sourceRecord = db.HseqRecords.Find(carVM.SourceRecordId);
car.LinkedRecords.Add(sourceRecord);
sourceRecord.LinkedRecords.Add(car);
db.SaveChanges();
}
}
catch (Exception e)
{
ViewData["EditError"] = e.Message;
return(PartialView("_CarNewView", carVM));
}
}
else
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
ViewData["EditError"] = "Please, correct all errors.";
return(PartialView("_CarNewView", carVM));
}
return(PartialView("_MainContentCallbackPanel"));
}
public ActionResult ApprovalGridViewAdd(HseqApprovalCreateViewModel approvalVM)
{
if (ModelState.IsValid)
{
try
{
if (approvalVM != null)
{
HseqApprovalRequest approval = new HseqApprovalRequest();
Mapper.Map(approvalVM, approval);
db.Entry(approval).State = EntityState.Added;
HseqRecord record = db.HseqRecords.Find(approvalVM.HseqRecordID);
record.Delegatables.Add(approval);
db.SaveChanges();
}
}
catch (Exception e)
{
ViewData["EditError"] = e.Message;
return(PartialView("_ApprovalNewView", approvalVM));
}
}
else
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
ViewData["EditError"] = "Please, correct all errors.";
return(PartialView("_ApprovalNewView", approvalVM));
}
return(PartialView("_MainContentCallbackPanel"));
}
public ActionResult Create(DelegatableVM ncrVM)
{
HseqRecord ncr = null;
if (ModelState.IsValid)
{
//ncr = db.NcrRecords.Find(ncrVM.HseqTask.HseqRecordID);
ncr = db.HseqRecords.Find(ncrVM.HseqTask.HseqRecordID);
ncrVM.HseqRecord = ncr;
HseqTask hseqTask = ncrVM.HseqTask;
_DelegatableService.AddHseqTaskRequest(ncr, hseqTask, db);
db.SaveChanges();
return(RedirectToAction("OpenAction", "HseqTasks"));
}
else
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
Console.WriteLine(errors);
}
return(View(ncrVM));
}
// //////////////// Abhi /////////////////////////////////////////////////////////////////////////////////////////
// GET: Ncrs/Edit/5
public ActionResult Create(int?recordId)
{
if (recordId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Ncr ncr = db.NcrRecords.Find(recordId);
HseqRecord hseqRecord = db.HseqRecords.Find(recordId);
if (hseqRecord == null)
{
return(HttpNotFound());
}
HseqApprovalRequest approvalRequest = new HseqApprovalRequest()
{
DueDate = DateTime.Now.AddDays(14),
OwnerID = Utils.GetCurrentApplicationUser(db).HseqUserID,
Status = ApprovalStatus.Active,
HseqRecordID = hseqRecord.HseqRecordID
};
DelegatableVM ncrVM = new DelegatableVM()
{
HseqRecord = hseqRecord,
HseqApprovalRequest = approvalRequest,
ApprovalOwners = db.HseqUsers
};
return(View(ncrVM));
}
//Type needs to come in
public ActionResult Edit(int?recordId)
{
if (recordId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
HseqTask hseqTask = db.HseqTasks.Find(recordId);
if (hseqTask == null)
{
return(HttpNotFound());
}
//Ncr hseqRecord = db.NcrRecords.Find(hseqTask.HseqRecordID);
HseqRecord hseqRecord = db.HseqRecords.Find(hseqTask.HseqRecordID);
if (hseqRecord == null)
{
return(HttpNotFound());
}
DelegatableVM delegatableVM = new DelegatableVM()
{
HseqRecord = hseqRecord,
HseqTask = hseqTask, /*hseqTask.AssigneeID = Utils.GetCurrentApplicationUser(db).HseqUserID;*/
TaskOwners = db.HseqUsers
};
return(View(delegatableVM));
}
public HseqRecord CreateLinkedRecord(int recordId, String recordSource, RecordType recordType, ApplicationDbContext db)
{
HseqRecord sourceRecord = GetSourceRecord(recordId, recordSource, db);
//var defaults = PopulateRecordTypeLinked(linkedRecord, RecordType.NCR);
HseqRecord newRecord = null;
if (recordType == RecordType.NCR)
{
newRecord = new Ncr(sourceRecord);
newRecord.RecordType = RecordType.NCR;
}
else if (recordType == RecordType.FIS)
{
newRecord = new Fis(sourceRecord);
newRecord.RecordType = RecordType.FIS;
}
else if (recordType == RecordType.CAR)
{
newRecord = new Car(sourceRecord);
newRecord.RecordType = RecordType.CAR;
}
else if (recordType == RecordType.PAR)
{
newRecord = new Par(sourceRecord);
newRecord.RecordType = RecordType.PAR;
}
newRecord.HseqRecordID = sourceRecord.HseqRecordID;
sourceRecord.LinkedRecords.Add(newRecord);
return(newRecord);
}
public ActionResult DeleteConfirmed(int id)
{
HseqCaseFile hseqCaseFile = db.HseqCaseFiles.Find(id);
Console.WriteLine(hseqCaseFile.HseqRecords);
Console.WriteLine(hseqCaseFile.HseqRecords.LongCount());
var tmp = new List <HseqRecord>(hseqCaseFile.HseqRecords);
foreach (var hsr in tmp)
{
//Ncr ncr = db.HseqRecords.Find(hsr.HseqRecordID);
HseqRecord hr = db.HseqRecords.Find(hsr.HseqRecordID);
if (hr is Ncr)
{
Ncr ncr = (Ncr)hr;
_LinkRecordService.RemoveLinkedRecords(ncr);
db.NcrRecords.Remove((Ncr)hr);
}
else if (hr is Fis)
{
Fis ncr = (Fis)hr;
_LinkRecordService.RemoveLinkedRecords(ncr);
db.FisRecords.Remove((Fis)hr);
}
else if (hr is Car)
{
Car ncr = (Car)hr;
_LinkRecordService.RemoveLinkedRecords(ncr);
db.CarRecords.Remove((Car)hr);
}
else if (hr is Par)
{
Par ncr = (Par)hr;
_LinkRecordService.RemoveLinkedRecords(ncr);
db.ParRecords.Remove((Par)hr);
}
}
db.HseqCaseFiles.Remove(hseqCaseFile);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private static void RemoveLinkedRecords(HseqRecord ncr)
{
if (ncr.LinkedRecords != null)
{
foreach (HseqRecord linkedRecord in ncr.LinkedRecords)
{
linkedRecord.LinkedRecords.Remove(ncr);
}
ncr.LinkedRecords = null;
}
}
public void RemoveLinkedRecords(HseqRecord record)
{
if (record.LinkedRecords != null)
{
foreach (HseqRecord linkedRecord in record.LinkedRecords)
{
linkedRecord.LinkedRecords.Remove(record);
}
record.LinkedRecords = null;
}
}
public HseqRecord PopulateLinkedRecordDefaults(String recordSource, HseqRecord linkedRecord, HseqRecord ncr, TempDataDictionary TempData)
{
ncr.HseqRecordID = linkedRecord.HseqRecordID;
ncr.EnteredBy = linkedRecord.EnteredBy;
ncr.ReportedBy = linkedRecord.ReportedBy;
//ncr.QualityCoordinator = linkedRecord.QualityCoordinator;
TempData["recordId"] = linkedRecord.HseqRecordID;
TempData["recordSource"] = recordSource;
linkedRecord.LinkedRecords.Add(ncr);
return(ncr);
}
public ActionResult CreateLinked(int recordId, String recordSource)
{
HseqRecord linkedRecord = _LinkRecordService.GetSourceRecord(recordId, recordSource, db);
Par par = (Par)_LinkRecordService.CreateLinkedRecord(recordId, recordSource, RecordType.PAR, db);
//PopulateDefaults(par);
par = (Par)_RecordService.PopulateRecordTypeDefaults(RecordType.PAR, par);
TempData["recordId"] = par.HseqRecordID;
TempData["recordSource"] = recordSource;
ViewBag.HseqCaseFileID = new SelectList(db.HseqCaseFiles, "HseqCaseFileID", "HseqCaseFileID", par.HseqCaseFileID);
ViewBag.CoordinatorID = new SelectList(db.HseqUsers, "HseqUserID", "FullName");
return(View("Create", par));
}
public HseqRecord CreateCaseFile(HseqRecord record, out HseqCaseFile hseqCaseFile, ApplicationDbContext db)
{
hseqCaseFile = new HseqCaseFile()
{
CaseNo = record.CaseNo
};
db.HseqCaseFiles.Add(hseqCaseFile);
db.SaveChanges();
record.HseqCaseFile = hseqCaseFile;
record.HseqCaseFileID = hseqCaseFile.HseqCaseFileID;
hseqCaseFile.HseqRecords.Add(record);
return(record);
}
public ActionResult Edit(DelegatableVM ncrVM)
{
Ncr ncr = null;
if (ModelState.IsValid)
{
HseqRecord hseqRecord = db.HseqRecords.Find(ncrVM.HseqApprovalRequest.HseqRecordID);
//ncrVM.Ncr = ncr;
HseqApprovalRequest hseqApprovalRequest = ncrVM.HseqApprovalRequest;
//Update Ncr Status
if (hseqRecord.RecordType == RecordType.NCR)
{
ncr = db.NcrRecords.Find(ncrVM.HseqApprovalRequest.HseqRecordID);
if (hseqApprovalRequest.Response == ApprovalResult.Approved)
{
ncr.NcrState = NcrState.DispositionApproved;
ncr.DateLastUpdated = DateTime.Now;
db.Entry(ncr).State = EntityState.Modified;
}
else if (hseqApprovalRequest.Response == ApprovalResult.Rejected)
{
ncr.NcrState = NcrState.DispositionRejected;
ncr.DateLastUpdated = DateTime.Now;
db.Entry(ncr).State = EntityState.Modified;
}
}
db.Entry(hseqApprovalRequest).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("OpenAction", "HseqApprovalRequests"));
}
else
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
Console.WriteLine(errors);
}
return(View(ncrVM));
}
internal HseqRecord CreateLinkRecord(HseqRecord record, int recordId, string recordSource, RecordType recordType, ApplicationDbContext db)
{
HseqRecord linkedRecord = GetSourceRecord(recordId, recordSource, db);
if (linkedRecord != null)
{
record.AlfrescoNoderef = linkedRecord.AlfrescoNoderef;
record.HseqCaseFileID = linkedRecord.HseqCaseFileID;
record.HseqCaseFile = linkedRecord.HseqCaseFile;
}
record.CreatedBy = _RecordService.GetCurrentUser().FullName;
record.CaseNo = linkedRecord.CaseNo;
record.RecordNo = linkedRecord.RecordNo;
record.LinkedRecords.Add(linkedRecord);
if (recordType == RecordType.NCR)
{
db.NcrRecords.Add((Ncr)record);
}
else if (recordType == RecordType.FIS)
{
db.FisRecords.Add((Fis)record);
}
else if (recordType == RecordType.CAR)
{
db.CarRecords.Add((Car)record);
}
else if (recordType == RecordType.PAR)
{
db.ParRecords.Add((Par)record);
}
linkedRecord.LinkedRecords.Add(record);
db.SaveChanges();
return(record);
}
public HseqRecord CreateCaseFile(HseqRecord record, out string caseNo, out HseqCaseFile hseqCaseFile, ApplicationDbContext db)
{
caseNo = GetNextCaseNumber(db);
record.CaseNo = caseNo;
record.RecordNo = caseNo;
hseqCaseFile = new HseqCaseFile()
{
CaseNo = caseNo
};
db.HseqCaseFiles.Add(hseqCaseFile);
db.SaveChanges();
record.HseqCaseFile = hseqCaseFile;
record.HseqCaseFileID = hseqCaseFile.HseqCaseFileID;
hseqCaseFile.HseqRecords.Add(record);
return(record);
}
internal HseqRecord GetSourceRecord(int recordId, string recordSource, ApplicationDbContext db)
{
HseqRecord linkedRecord = null;
if (recordSource.Equals(RecordType.NCR.ToString()))
{
linkedRecord = db.NcrRecords.Find(recordId);
}
else if (recordSource.Equals(RecordType.FIS.ToString()))
{
linkedRecord = db.FisRecords.Find(recordId);
}
else if (recordSource.Equals(RecordType.CAR.ToString()))
{
linkedRecord = db.CarRecords.Find(recordId);
}
else if (recordSource.Equals(RecordType.PAR.ToString()))
{
linkedRecord = db.ParRecords.Find(recordId);
}
return(linkedRecord);
}
//public void AddHseqApprovalRequest(HseqRecord record, int? ApproverID, HseqApprovalRequest hseqApprovalRequest, ApplicationDbContext db)
//{
// if (record is Ncr)
// {
// Ncr ncr = (Ncr)record;
// if (hseqApprovalRequest == null) {
// hseqApprovalRequest = new HseqApprovalRequest();
// }
// if (ApproverID != null && ApproverID > 0)
// {
// HseqApprovalRequest approvalRequest = new HseqApprovalRequest();
// //approvalRequest.Owner = db.HseqUsers.Find(_RecordService.GetCurrentUser().Id);
// approvalRequest.Owner = db.HseqUsers.Find(ApproverID);
// approvalRequest.Assignee = db.HseqUsers.Find(GetCurrentApplicationUser().HseqUserID);
// approvalRequest.DateAssigned = DateTime.Now;
// if (hseqApprovalRequest.Title == null)
// {
// approvalRequest.Title = ncr.Title;
// }
// else {
// approvalRequest.Title = hseqApprovalRequest.Title;
// }
// if (hseqApprovalRequest.Description == null)
// {
// approvalRequest.Description = ncr.Description;
// }
// else {
// approvalRequest.Description = hseqApprovalRequest.Description;
// }
// if (hseqApprovalRequest.DueDate == null || hseqApprovalRequest.DueDate <DateTime.Now.Subtract(TimeSpan.FromDays(1)))
// {
// approvalRequest.DueDate = DateTime.Now.AddDays(14);
// }
// else {
// approvalRequest.DueDate = hseqApprovalRequest.DueDate;
// }
// approvalRequest.Status = ApprovalStatus.Active;
// approvalRequest.Response = ApprovalResult.Waiting;
// approvalRequest.HseqRecordID = ncr.HseqRecordID;
// ncr.Delegatables.Add(approvalRequest);
// }
// }
//}
public HseqApprovalRequest AddHseqApprovalRequest(HseqRecord record, HseqApprovalRequest approvalRequest, ApplicationDbContext db)
{
// if (record is Ncr)
//{
//Ncr ncr = (Ncr)record;
if (approvalRequest == null)
{
approvalRequest = new HseqApprovalRequest();
}
approvalRequest.Owner = db.HseqUsers.Find(approvalRequest.OwnerID);
approvalRequest.DateAssigned = DateTime.Now;
if (approvalRequest.DueDate == null || approvalRequest.DueDate < DateTime.Now.Subtract(TimeSpan.FromDays(1)))
{
approvalRequest.DueDate = DateTime.Now.AddDays(14);
}
else
{
approvalRequest.DueDate = approvalRequest.DueDate;
}
//approvalRequest.Status = ApprovalStatus.Active;
//approvalRequest.Response = ApprovalResult.Waiting;
//approvalRequest.HseqRecordID = ncr.HseqRecordID;
record.Delegatables.Add(approvalRequest);
return(approvalRequest);
//}
//return null;
}
public ActionResult Create(DelegatableVM ncrVM)
{
HseqRecord hseqRecord = null;
if (ModelState.IsValid)
{
hseqRecord = db.HseqRecords.Find(ncrVM.HseqApprovalRequest.HseqRecordID);
ncrVM.HseqRecord = hseqRecord;
HseqApprovalRequest hseqApprovalRequest = ncrVM.HseqApprovalRequest;
if (hseqRecord.RecordType == RecordType.NCR)
{
Ncr ncr = db.NcrRecords.Find(ncrVM.HseqRecord.HseqRecordID);
ncr.NcrState = NcrState.DispositionProposed;
ncr.DateLastUpdated = DateTime.Now;
}
else
{
hseqRecord.DateLastUpdated = DateTime.Now;
}
HseqApprovalRequest approvalRequest = _DelegatableService.AddHseqApprovalRequest(hseqRecord, hseqApprovalRequest, db);
//ncr.Delegatables.Add(approvalRequest);
db.SaveChanges();
return(RedirectToAction("OpenAction", "HseqApprovalRequests"));
}
else
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
Console.WriteLine(errors);
}
return(View(ncrVM));
}
public ActionResult LinkExistingRecord(Ncr ncr, int?LinkedRecordsID)
{
if (LinkedRecordsID != null)
{
Ncr ncrOrig = db.NcrRecords.Find(ncr.HseqRecordID);
HseqRecord LinkedRecord = db.HseqRecords.Find(LinkedRecordsID);
if (ncrOrig != null && LinkedRecord != null)
{
ncrOrig.LinkedRecords.Add(LinkedRecord);
LinkedRecord.LinkedRecords.Add(ncrOrig);
db.SaveChanges();
}
var availableRecords = from h in db.HseqRecords
where h.RecordType != RecordType.NCR
select h;
ViewBag.LinkedRecordsID = new SelectList(availableRecords, "HseqRecordID", "LinkRecordForDisplay");
}
return(RedirectToAction("LinkExistingRecord", "Ncrs", ncr.RecordNo));
//return View(ncr);
}
///////////////////////////////////////////////////////////
public ActionResult Create(int?recordId)
{
if (recordId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Ncr ncr = db.NcrRecords.Find(recordId);
HseqRecord hseqRecord = db.HseqRecords.Find(recordId);
if (hseqRecord == null)
{
return(HttpNotFound());
}
HseqTask hseqTask = new HseqTask()
{
DueDate = DateTime.Now.AddDays(14),
OwnerID = Utils.GetCurrentApplicationUser(db).HseqUserID,
Status = TaskStatus.NotStarted,
HseqRecordID = hseqRecord.HseqRecordID
};
DelegatableVM delegatableVM = new DelegatableVM()
{
HseqRecord = hseqRecord,
HseqTask = hseqTask, /*hseqTask.AssigneeID = Utils.GetCurrentApplicationUser(db).HseqUserID;*/
TaskOwners = db.HseqUsers
};
//ViewBag.DispositionTypeID = new SelectList(db.DispositionTypes, "DispositionTypeID", "Name", ncr.DispositionTypeID);
//ViewBag.AssigneeID = new SelectList(db.HseqUsers, "HseqUserID", "FullName", ncrVM.HseqTask.AssigneeID);
//ViewBag.ApproverID = new SelectList(db.HseqUsers, "HseqUserID", "FullName", ncrVM.HseqTask.OwnerID);
return(View(delegatableVM));
}
public ActionResult MainContentCallbackPanel()
// DXCOMMENT: Pass a data model for GridView in the PartialView method's second parameter
{
if (DevExpressHelper.IsCallback)
{
NavigationFilter.RecordTypeCheckState = null;
NavigationFilter.ResponsibleAreaCheckState = null;
NavigationFilter.CoordinatorsCheckState = null;
NavigationFilter.RecordTypes = null;
NavigationFilter.ResponsibleAreaIds = null;
NavigationFilter.CoordinatorIds = null;
//Checked, Unchecked, Indeterminate
NavigationFilter.RecordTypeCheckState = Request.Params["recordTypeCheckState"];
NavigationFilter.ResponsibleAreaCheckState = Request.Params["responsibleAreaCheckState"];
NavigationFilter.CoordinatorsCheckState = Request.Params["coordinatorsCheckState"];
//Record Type
if (!string.IsNullOrEmpty(Request.Params["recordTypeCheckedNodes"]))
{
string recordTypeNodes = Request.Params["recordTypeCheckedNodes"];
NavigationFilter.RecordTypes = recordTypeNodes.Split(',');
setActiveTab();
}
//Responsible Area Type
if (!string.IsNullOrEmpty(Request.Params["responsibleAreaCheckedNodes"]))
{
string responsibleAreaNodes = Request.Params["responsibleAreaCheckedNodes"];
NavigationFilter.ResponsibleAreaIds = Array.ConvertAll(responsibleAreaNodes.Split(','), int.Parse);
}
if (!string.IsNullOrEmpty(Request.Params["coordinatorsCheckedNodes"]))
{
string responsibleAreaNodes = Request.Params["coordinatorsCheckedNodes"];
NavigationFilter.CoordinatorIds = Array.ConvertAll(responsibleAreaNodes.Split(','), int.Parse);
}
//ViewData["Collapsed"] = false;
//edit
if (!string.IsNullOrEmpty(Request.Params["EditRecord"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]) && !string.IsNullOrEmpty(Request.Params["recordId"]))
{
string currentActiveView = Request.Params["currentActiveView"];
int recordId = int.Parse(Request.Params["recordId"]);
if (currentActiveView.Contains("Task"))
{
HseqTask record = db.HseqTasks.Find(recordId);
HseqTaskEditViewModel HseqTaskEditVM = Mapper.Map <HseqTask, HseqTaskEditViewModel>(record);
ViewData["record"] = HseqTaskEditVM;
ViewData["currentview"] = "_Task" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Approval"))
{
HseqApprovalRequest record = db.HseqApprovalRequests.Find(recordId);
HseqApprovalEditViewModel HseqApprovalEditVM = Mapper.Map <HseqApprovalRequest, HseqApprovalEditViewModel>(record);
ViewData["record"] = HseqApprovalEditVM;
ViewData["currentview"] = "_Approval" + EDIT_VIEW_PREFIX;
}
////////////////////////////////////////
else if (currentActiveView.Contains("Ncr"))
{
Ncr record = db.NcrRecords.Find(recordId);
NcrEditViewModel ncrEditVM = Mapper.Map <Ncr, NcrEditViewModel>(record);
ViewData["record"] = ncrEditVM;
ViewData["currentview"] = "_Ncr" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Car"))
{
Car record = db.CarRecords.Find(recordId);
CarEditViewModel carEditVM = Mapper.Map <Car, CarEditViewModel>(record);
ViewData["record"] = carEditVM;
ViewData["currentview"] = "_Car" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Par"))
{
Par record = db.ParRecords.Find(recordId);
ParEditViewModel parEditVM = Mapper.Map <Par, ParEditViewModel>(record);
ViewData["record"] = parEditVM;
ViewData["currentview"] = "_Par" + EDIT_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Fis"))
{
Fis record = db.FisRecords.Find(recordId);
FisEditViewModel fisEditVM = Mapper.Map <Fis, FisEditViewModel>(record);
ViewData["record"] = fisEditVM;
ViewData["currentview"] = "_Fis" + EDIT_VIEW_PREFIX;
}
}
}
//new
else if (!string.IsNullOrEmpty(Request.Params["NewRecord"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]))
{
string currentActiveView = Request.Params["currentActiveView"];
if (currentActiveView.Contains("Ncr"))
{
Ncr ncr = new Ncr();
ncr.CaseNo = _RecordService.GetNextCaseNumber(db);
ncr.RecordNo = ncr.CaseNo;
ncr.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
ncr.DateCreated = DateTime.Now;
ncr.RecordType = RecordType.NCR;
ncr.NcrSource = NcrSource.Internal;
ncr.NcrState = NcrState.New;
NcrCreateViewModel carVM = Mapper.Map <Ncr, NcrCreateViewModel>(ncr);
ViewData["record"] = carVM;
ViewData["currentview"] = "_Ncr" + NEW_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Car"))
{
Car car = new Car();
car.CaseNo = _RecordService.GetNextCaseNumber(db);
car.RecordNo = car.CaseNo;
car.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
car.DateCreated = DateTime.Now;
car.RecordType = RecordType.CAR;
CarCreateViewModel carVM = Mapper.Map <Car, CarCreateViewModel>(car);
ViewData["record"] = carVM;
ViewData["currentview"] = "_Car" + NEW_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Par"))
{
Par par = new Par();
par.CaseNo = _RecordService.GetNextCaseNumber(db);
par.RecordNo = par.CaseNo;
par.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
par.DateCreated = DateTime.Now;
par.RecordType = RecordType.PAR;
ParCreateViewModel parVM = Mapper.Map <Par, ParCreateViewModel>(par);
ViewData["record"] = parVM;
ViewData["currentview"] = "_Par" + NEW_VIEW_PREFIX;
}
else if (currentActiveView.Contains("Fis"))
{
Fis fis = new Fis();
fis.CaseNo = _RecordService.GetNextCaseNumber(db);
fis.RecordNo = fis.CaseNo;
fis.CreatedBy = _RecordService.GetCurrentApplicationUser().FullName;
fis.DateCreated = DateTime.Now;
fis.RecordType = RecordType.FIS;
FisCreateViewModel fisVM = Mapper.Map <Fis, FisCreateViewModel>(fis);
ViewData["record"] = fisVM;
ViewData["currentview"] = "_Fis" + NEW_VIEW_PREFIX;
}
}
}
//// Task ///////////////////
else if (!string.IsNullOrEmpty(Request.Params["addTask"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]) && !string.IsNullOrEmpty(Request.Params["recordId"]))
{
string currentActiveView = Request.Params["currentActiveView"];
int recordId = int.Parse(Request.Params["recordId"]);
HseqTask hseqTask = new HseqTask()
{
Status = TaskStatus.NotStarted
};
HseqRecord hseqRecord = db.HseqRecords.Find(recordId);
hseqTask.HseqRecordID = hseqRecord.HseqRecordID;
hseqTask.HseqRecord = hseqRecord;
HseqTaskCreateViewModel hseqTaskVM = Mapper.Map <HseqTask, HseqTaskCreateViewModel>(hseqTask);
ViewData["record"] = hseqTaskVM;
ViewData["currentview"] = "_Task" + NEW_VIEW_PREFIX;
}
}
//// Approval ///////////////////
else if (!string.IsNullOrEmpty(Request.Params["addApproval"]))
{
if (!string.IsNullOrEmpty(Request.Params["currentActiveView"]) && !string.IsNullOrEmpty(Request.Params["recordId"]))
{
string currentActiveView = Request.Params["currentActiveView"];
int recordId = int.Parse(Request.Params["recordId"]);
HseqApprovalRequest hseqApproval = new HseqApprovalRequest()
{
Response = ApprovalResult.Waiting,
Status = ApprovalStatus.Active,
DateAssigned = DateTime.Now
};
HseqRecord hseqRecord = db.HseqRecords.Find(recordId);
hseqApproval.HseqRecordID = hseqRecord.HseqRecordID;
hseqApproval.HseqRecord = hseqRecord;
HseqApprovalCreateViewModel hseqApprovalVM = Mapper.Map <HseqApprovalRequest, HseqApprovalCreateViewModel>(hseqApproval);
ViewData["record"] = hseqApprovalVM;
ViewData["currentview"] = "_Approval" + NEW_VIEW_PREFIX;
}
}
//// Linked Record ///////////////////
else if (!string.IsNullOrEmpty(Request.Params["createLinkedRecord"]) &&
!string.IsNullOrEmpty(Request.Params["linkedRecordDetails"]))
{
if (!string.IsNullOrEmpty(Request.Params["recordId"]))
{
int recordId = int.Parse(Request.Params["recordId"]);
var linkedRecordDetails = Request.Params["linkedRecordDetails"].Split('-');
var sourceRecord = linkedRecordDetails[0];
var targetRecord = linkedRecordDetails[1];
//Ncr to Car
if (sourceRecord == "NCR")
{
if (targetRecord == "CAR")
{
Ncr ncr = db.NcrRecords.Find(recordId);
Car car = new Car(ncr)
{
CreatedBy = _RecordService.GetCurrentApplicationUser().FullName,
DateCreated = DateTime.Now,
RecordType = RecordType.CAR
};
CarVM carVM = new CarVM()
{
Car = car,
LinkedRecord = true,
SourceRecordId = ncr.HseqRecordID
};
ViewData["record"] = carVM;
ViewData["currentview"] = "_Car" + LINKED_VIEW_PREFIX;
}
}
}
}
else
{
ViewData["currentview"] = "_MainContentTabPanel";
}
}
return(PartialView("_MainContentCallbackPanel"));
}