public static void ProcessWorkflow(RigOapChecklist rigOapChecklist, ILog log, IIrmaOapDbContext context)
{
var wfs = new WorkflowEngineService(log);
var wfir = new RigOapChecklistWorkflowRepository(context, log);
var peopler = new PeopleRepository(context, log);
var workflowActivity = new Genericlist()
{
DisplayName = $"Genericlist_{rigOapChecklist.Id}"
};
var workflowinstance = wfir.GetWorkflowByChecklist(rigOapChecklist.Id);
var people = new List <Person>()
{
peopler.Get(rigOapChecklist.OwnerId)
};
var request = new AssignmentRequest()
{
Users = people
};
wfs.Process(workflowActivity, new Version(workflowinstance.Workflow.Major, workflowinstance.Workflow.Minor), workflowinstance, workflowinstance.Transition, request);
}
public static void ProcessWorkflow(this RigOapChecklist rigOapChecklist, IRigOapChecklistWorkflowService rigOapChecklistWorkflowService, IWorkflowEngineService workflowEngineService, IWorkflowService workflowService, WorkflowTransition transition, WorkflowRequest request, ILog log)
{
var workflow = workflowService.GetActiveWorkflow(rigOapChecklist.OapChecklist.OapType.ChecklistLayoutId.Value);
//Create the Workflow Activity
var workflowActivity = workflow.GetActivity(rigOapChecklist.Id);
if (workflowActivity == null)
{
log.Error($" Workflow Activity was not found for checklist : { rigOapChecklist.Id}");
return;
}
//Create the RigOapChecklistWorkflow instance
var rigChecklistWorkflow = rigOapChecklistWorkflowService.GetWorkflowByChecklist(rigOapChecklist.Id);
if (rigChecklistWorkflow == null)
{
log.Error($" Workflow instance was not found for checklist : { rigOapChecklist.Id}");
return;
}
var version = new Version(workflow.Major, workflow.Minor);
//Start the Workflow Instance and All the store the instance details
//Get the Current Principal And Assign Him to Workflow to
workflowEngineService.Process(workflowActivity, version, rigChecklistWorkflow, transition, request);
}
public virtual async Task <ActionResult> CreateProtocol(string OapChecklistId, int OwnerId)
{
var audit = (OapAudit)Session["OapAudit"];
List <RigOapChecklist> protocolList = new List <RigOapChecklist>();
IEnumerable <OapChecklist> OapChecklist = GetProtocols();
string[] values = OapChecklistId.Split(';');
foreach (var value in values)
{
int checklistId = OapChecklist.Where(p => p.Name == value).FirstOrDefault().Id;
RigOapChecklist protocol = new RigOapChecklist();
protocol.OapchecklistId = checklistId;
protocol.RigId = audit.RigId.ToString();
protocol.OwnerId = OwnerId;
protocol.Title = "Audit Protocol by " + UtilitySystem.CurrentUserName;
protocol.ChecklistDateTime = DateTime.UtcNow;
var count = audit.OapAuditProtocols.Where(p => p.RigOapChecklist.OapchecklistId == protocol.OapchecklistId).Count();
if (count == 0)
{
protocolList.Add(protocol);
}
}
IEnumerable <RigOapChecklist> model = protocolList;
var protocols = (model.Count() != 0) ? await OapAuditClient.AddProtocolsAsync(audit.Id, model) : throw new Exception("Protocol Already Exists");
return(TryCatchCollectionDisplayPartialView("ProtocolsToAuditPartial", "GenericDashBoardErrorsKey", () => protocols?.Result?.Data));
}
public void SignWorkFlow(RigOapChecklist existingRigChecklist, int userId, int order, string comment)
{
var verifier = existingRigChecklist.VerifiedBy.ToList().FirstOrDefault(v => v.UserId == userId);
if (verifier == null)
{
return;
}
// Close task and mark the next user's task as pending
var existingTask = irmaTaskService.CloseTask("Oap - Workflow", existingRigChecklist.RigChecklistUniqueId, userId);
var nextSigner = existingRigChecklist.VerifiedBy.OrderBy(v => v.Order).FirstOrDefault(v => v.Order > verifier.Order);
//var nextSignerTask = irmaTaskService.Filter(t => t.Source == "Oap - Workflow" && t.SourceId == existingRigChecklist.RigChecklistUniqueId && t.AssigneeId == nextSigner.UserId).FirstOrDefault();
verifier.SignedOn = DateTime.UtcNow;
verifier.UpdatedDateTime = DateTime.UtcNow;
verifier.Status = WorkflowStatus.Completed.ToString();
verifier.Comment = comment;
if (nextSigner != null)
{
nextSigner.Status = WorkflowStatus.Pending.ToString();
}
checklistRepository.Update(existingRigChecklist);
}
private void AssignReviewAndTasksToAuditOIM(RigOapChecklist checklist)
{
string oimPassport = adminCustomRepository.GetByName("OIM")?.Value;
var oimUser = peopleService.GetByLogin(oimPassport);
//get audit info from checklist id and then assign below audit values
if (oimPassport != null && oimUser != null)
{
irmaTaskService.Add(new IrmaTask()
{
Source = "cOap",
SourceId = checklist.Id.ToString(),
SourceUrl = string.Format("/cOap/OapAuditReport/Index/{0}", checklist.Id), // Needs improvement - Does not have access to the MVC routing from the api
AssigneeId = oimUser.Id,
Comment = string.Format("Audit {0} has been submitted and is available for your review", checklist.RigChecklistUniqueId),
AssignedDateTime = DateTime.UtcNow,
Status = "Open"
});
int rigId;
int.TryParse(checklist.RigId, out rigId);
reviewService.Add(new IrmaReview()
{
ReviewerPassportId = oimUser.Id,
RigId = rigId,
SourceForm = "Oap",
SourceFormId = checklist.Id.ToString(),
});
}
}
private void AssignReviewAndTasksToOIM(RigOapChecklist checklist)
{
string oimPassport = adminCustomRepository.GetByName("OIM")?.Value;
var oimUser = peopleService.GetByLogin(oimPassport);
if (oimPassport != null && oimUser != null)
{
irmaTaskService.Add(new IrmaTask()
{
Source = "Oap",
SourceId = checklist.Id.ToString(),
SourceUrl = string.Format("/Oap/MasterOversight/List/{0}", checklist.Id), // Needs improvement - Does not have access to the MVC routing from the api
AssigneeId = oimUser.Id,
Comment = string.Format("Master Oversight checklist {0} has been submitted and is available for your review", checklist.RigChecklistUniqueId),
AssignedDateTime = DateTime.UtcNow,
Status = "Open"
});
int rigId;
reviewService.Add(new IrmaReview()
{
ReviewerPassportId = oimUser.Id,
// RigId = rigId,
SourceForm = "Oap",
SourceFormId = checklist.Id.ToString(),
});
}
}
public async Task <ActionResult> AddScheduledChecklist(int numberOfDays, DateTime StartingAt, string title, string description)
{
if (StartingAt != null && numberOfDays > 0)
{
var lifeSaverChecklist = OapChecklistClient.GetByNameAsync("Life Savers").Result?.Result?.Data;
if (lifeSaverChecklist == null)
{
throw new Exception("The life savers checklist was not found. Please contact the development support team");
}
for (int i = 0; i < numberOfDays; i++)
{
var checklistDate = StartingAt.AddDays(i);
RigOapChecklist checklist = new RigOapChecklist()
{
Status = "Open",
ChecklistDateTime = checklistDate,
OapchecklistId = lifeSaverChecklist.Id,
IsAutoScheduled = true,
//RigId = UtilitySystem.Settings.RigId.ToString(),
Title = title,
Description = description,
CreatedDateTime = DateTime.UtcNow
};
await RigOapChecklistClient.AddRigChecklistAsync(checklist);
}
}
return(DisplayLifeSaverScheduleAbdJobs());
}
public ActionResult UpdateRigChecklist(RigOapChecklist model)
{
// TODO: Add update logic here
var response = RigOapChecklistClient.UpdateRigChecklistAsync(model).Result;
return(RedirectToAction("Index"));
}
public virtual async Task <ActionResult> CreateAudit(OapAudit model)
{
RigOapChecklist modelr = new RigOapChecklist()
{
OapchecklistId = 69, OwnerId = UtilitySystem.CurrentUserId, Title = "Audit-" + model.Id.ToString(), RigId = model.RigId.ToString()
};
model.CreatedBy = model.UpdatedBy;
var oapaudit = new OapAuditProtocol();
oapaudit.AuditId = model.Id;
oapaudit.RigOapCheckListId = Guid.Empty;
oapaudit.RigOapChecklist = modelr;
model.OapAuditProtocols = new ObservableCollection <OapAuditProtocol>();
model.OapAuditProtocols.Add(oapaudit);
// model.SiteId = "corp";
var response = await OapAuditClient.AddOapAuditAsync(model);
// return RedirectToAction("Index");
// ViewBag.SelectedRigId = model.RigId;
return(RedirectToAction("RefreshAll"));
// return null;
// return PartialView("OapAuditPartial", GetAuditData());
}
public void RejectWorkFlow(RigOapChecklist checklist, int userId, int order, string comment)
{
// Closes existing user task
irmaTaskService.CloseTask("Oap - Workflow", checklist.RigChecklistUniqueId, userId);
//Reverse to the previous verifier
var currentSigner = checklist.VerifiedBy.ToList().FirstOrDefault(v => v.UserId == userId && v.Order == order);
var previousSigner = checklist.VerifiedBy.ToList().OrderByDescending(v => v.Order).FirstOrDefault(v => v.Order < order);
currentSigner.Status = WorkflowStatus.Rejected.ToString();
currentSigner.SignedOn = DateTime.UtcNow;
currentSigner.UpdatedDateTime = DateTime.UtcNow;
currentSigner.Comment = comment;
previousSigner.Status = WorkflowStatus.Pending.ToString();
previousSigner.SignedOn = null;
previousSigner.UpdatedDateTime = DateTime.UtcNow;
irmaTaskService.Add(new Models.Domain.IRMA.IrmaTask
{
Source = "Oap - Workflow",
SourceId = checklist.RigChecklistUniqueId.ToString(),
AssigneeId = previousSigner.UserId,
AssignedDateTime = DateTime.UtcNow,
Comment = $"The checklist {checklist.RigChecklistUniqueId} was rejected, please review it before resubmitting",
Status = "Open"
});
checklistRepository.Update(checklist);
}
public static bool HasComments(this OapGenericCheckListFlatModel question, RigOapChecklist rigOapChecklist)
{
IOAPServiceDataModel dataModel = OAPServiceSystem.GetServiceModel(OAPServiceSystem.OAPDataModelType.Comment);
IEnumerable <CommentModel> comments = dataModel.GetItems(string.Format("QuestionId=\"{0}\" AND SourceFormId=\"{1}\"", question.QuestionId, rigOapChecklist.Id.ToString()), "Id").Cast <CommentModel>();
return(comments.Count() > 0);
}
private RigOapChecklist CreateFSOChecklist(int OwnerId, string Title, DateTime ChecklistDateTime)
{
OapChecklist oapChecklist = OapChecklistClient.GetByNameAsync("FSO Checklist").Result?.Result?.Data;
if (oapChecklist == null)
{
ViewData["UpdateError"] = true;
return(null);
}
RigOapChecklist checklist = new RigOapChecklist();
checklist.CreatedBy = UtilitySystem.CurrentUserName;
checklist.OwnerId = OwnerId; //UtilitySystem.CurrentUserId;
checklist.CreatedDateTime = DateTime.UtcNow;
checklist.ChecklistDateTime = ChecklistDateTime; //DateTime.UtcNow;
checklist.Title = Title;
checklist.UpdatedDateTime = DateTime.UtcNow;
checklist.Status = "Open";
checklist.OapchecklistId = oapChecklist.Id;
var newChecklist = RigOapChecklistClient.AddRigChecklistAsync(checklist).Result?.Result?.Data;
return(newChecklist);
}
public async Task <ActionResult> DeleteRigChecklist(RigOapChecklist model)
{
if (model.Id != Guid.Empty)
{
var response = await RigOapChecklistClient.DeleteRigOapChecklistAsync(model.Id);
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> AddChecklist(RigOapChecklist model)
{
//model.RigId = OapUtilities.GetRigId();
model.CreatedDateTime = DateTime.UtcNow;
var response = await RigOapChecklistClient.AddRigChecklistAsync(model);
return(RigChecklists());
}
public WebApiResult <RigOapChecklist> GetAll()
{
var result = new WebApiResult <RigOapChecklist>();
RigOapChecklist r = new RigOapChecklist();
// r.RigId
result.Data = r;
return(result);
//return TryCatch<GetAllRigOapChecklistRequest, IEnumerable<RigOapChecklist>>(new GetAllRigOapChecklistRequest(string.Empty));
}
// GET: IRMA/Checklist/1
public ActionResult Checklist(int id)
{
RigOapChecklist checklist = RigOapChecklistClient.GetByUniqueIdAsync(id).Result?.Result?.Data;
if (checklist == null)
{
return(RedirectToAction("Index"));
}
return(View(checklist));
}
public virtual async Task <ActionResult> CreateRigChecklist(RigOapChecklist model)
{
// TODO: Add insert logic here
model.RigId = "0";
var response = await RigOapChecklistClient.AddRigChecklistAsync(model);
if (ModelState.ContainsKey("RigChecklistUniqueId")) // Handled in the API
{
ModelState["RigChecklistUniqueId"].Errors.Clear();
}
return(RigChecklists());
}
public void Cancel(RigOapChecklist checklist, int userId, int order, string comment)
{
var verifier = checklist.VerifiedBy.FirstOrDefault(v => v.Order == order && v.UserId == userId);
irmaTaskService.CloseTask("Oap - Workflow", checklist.RigChecklistUniqueId, userId);
verifier.Status = WorkflowStatus.Canceled.ToString();
verifier.SignedOn = DateTime.UtcNow;
verifier.UpdatedDateTime = DateTime.UtcNow;
verifier.Comment = comment;
checklist.Status = ChecklistStatus.Canceled.ToString();
checklistRepository.Update(checklist);
}
protected override void Execute(NativeActivityContext context)
{
var rigChecklistId = RigOapChecklistId.Get(context);
try
{
RigChecklistService = Container.GetInstance <IRigOapChecklistService>();
IrmaTaskService = Container.GetInstance <IIrmaTaskService>();
peopleService = Container.GetInstance <IPeopleService>();
}
catch (Exception ex)
{
//TODO : Add error logging
}
RigChecklist = RigChecklistService.Get(rigChecklistId);
}
private IList <RigOapChecklistQuestionFinding> GetQuestionFindings(RigOapChecklist checklist, Guid questionId)
{
if (checklist != null)
{
var question = checklist.Questions.FirstOrDefault(q => q.Id == questionId);
if (question != null)
{
var qFindings = GetClient <OapChecklistFindingClient>().GetAllFindingsForQuestionAsync(question.Id).Result.Result.Data;
return(qFindings);
}
return(null);
}
return(null);
}
public void StartChecklistWorkFlow(RigOapChecklist checklist)
{
var _checklist = checklistRepository.Get(checklist.Id);
if (checklist == null)
{
return;
}
_checklist.Status = WorkflowStatus.Pending.ToString();
RigOapChecklistAssessor leadAssessor = null;
foreach (var a in _checklist.Assessors)
{
if (a.IsLead)
{
leadAssessor = a;
break;
}
}
if (leadAssessor != null)
{
irmaTaskService.Add(new IrmaTask
{
Source = "Oap - Workflow",
SourceId = _checklist.RigChecklistUniqueId.ToString(),
AssigneeId = leadAssessor.UserId,
AssignedDateTime = DateTime.UtcNow,
Comment = $"You have been assigned checklist {_checklist.RigChecklistUniqueId} for review/approval",
Status = "Open"
});
}
var firstVerifier = _checklist.VerifiedBy.OrderBy(v => v.Order).FirstOrDefault();
firstVerifier.Status = WorkflowStatus.Pending.ToString();
var assessorEmail = peopleService.Get(leadAssessor.UserId).Email;
irmaTaskService.SendEmail(assessorEmail, "Rig Checklist Verfication", $"You have been assigned to checklist {_checklist.RigChecklistUniqueId} for review.");
checklistRepository.Update(_checklist);
}
public static IList <OapGenericCheckListFlatModel> ToFlattenedModels(this RigOapChecklist protocol)
{
var questions = protocol.Questions;
var genericFlatModelList = new List <OapGenericCheckListFlatModel>();
if (questions.Any())
{
genericFlatModelList = (from g in protocol.OapChecklist.Groups
from sg in g.SubGroups
from t in sg.Topics
from q in t.Questions
select new OapGenericCheckListFlatModel(protocol.Id,
protocol.OapChecklist.Id,
g.Id,
g.Name,
g.Order,
g.OapGraphic?.Image ?? new byte[0],
sg.Id,
sg.Name,
sg.Order,
sg.IsVisible,
sg.IsPlantMonitoring,
sg.IsThirdPartyActivities,
sg.IsWorkInstructions,
t.Topic,
questions.FirstOrDefault(rq => rq.OapChecklistQuestionId == q.Id)?.Id,
q.Id,
q.Question,
q.Order,
q.Help,
questions.FirstOrDefault(rq => rq.OapChecklistQuestionId == q.Id)?.Comment,
q.Weight,
q.Maximum,
q.Criticality,
q.Section,
q.BasicCauseClassification,
questions.FirstOrDefault(rq => rq.OapChecklistQuestionId == q.Id)?.Answers?.ToDictionary(),
questions.FirstOrDefault(rq => rq.OapChecklistQuestionId == q.Id)?.OapChecklistQuestion?.OapChecklistQuestionDataType?.Code ?? "RBL",
questions.FirstOrDefault(rq => rq.OapChecklistQuestionId == q.Id)?.OapChecklistQuestion?.OapFrequency?.Name ?? "")
).OrderBy(x => x.GroupOrder).ThenBy(x => x.SubGroupOrder).ThenBy(x => x.QuestionOrdinal).ToList();
}
return(genericFlatModelList);
}
public static void AddWorkflow(RigOapChecklist rigOapChecklist, ILog log, IIrmaOapDbContext context)
{
var workflowActivity = new Genericlist()
{
DisplayName = $"Genericlist_{rigOapChecklist.Id}"
};
var activities = new List <Activity>(WorkflowInspectionServices.GetActivities(workflowActivity));
var indent = 0;
activities.ForEach((act) => Console.WriteLine("{0}{1}", new string(' ', indent), act.DisplayName));
string serializedAB = ToXaml(activities[0]);
var version = new Version(1, 0);
var wfr = new WorkflowRepository(context, log);
var workflow = wfr.GetActiveWorkflow(8);
//var workflow = new Irma.Models.Domain.Workflow.Workflow();
//workflow.Name = "BarrierAuthorityOIM";
//workflow.Major = version.Major;
//workflow.Minor = version.Minor;
//workflow.Active = true;
//workflow.ActivityXaml = ToXaml(workflowActivity);
//var workflowType = workflowActivity.GetType();
//workflow.Assembly = workflowType.Assembly.GetName().Name;
//workflow.Type = workflowType.FullName;
var workflowinstance = new RigOapChecklistWorkflow(rigOapChecklist)
{
Name = $"{workflow.Name} Instance",
Workflow = workflow
};
var wfs = new WorkflowEngineService(log);
var wfir = new RigOapChecklistWorkflowRepository(context, log);
wfs.Start(workflowActivity, version, workflowinstance);
wfir.Add(workflowinstance);
}
public static RigOapChecklist UpdateChecklist(RigOapChecklistClient client, RigOapChecklist checklist, GridRouteTypes type, int originalHasCode, string gridErrorKey, ViewDataDictionary viewData)
{
if (client == null)
{
viewData[gridErrorKey] = "Rig Oap client is null. Refresh Page and try again. Contact system administrator if the error persists";
return(checklist);
}
var currentHashCode = checklist.GetHashCode();
if (currentHashCode != originalHasCode)
{
try
{
switch (type)
{
case GridRouteTypes.Add:
case GridRouteTypes.Update:
case GridRouteTypes.Delete:
var updateResponse = client.UpdateRigChecklistAsync(checklist).Result;
if (updateResponse.Result.Errors.Any())
{
DisplayGridErrors(updateResponse.Result.Errors, gridErrorKey, viewData);
}
else
{
checklist = updateResponse.Result.Data;
}
break;
}
}
catch (Exception ex)
{
viewData[gridErrorKey] = ex.Message;
}
return(checklist);
}
return(checklist);
}
public virtual async Task <ActionResult> CreateProtocolChecklist(int OapChecklistId, int OwnerId)
{
RigOapChecklist model = new RigOapChecklist()
{
OapchecklistId = OapChecklistId, OwnerId = OwnerId
};
var audit = (OapAudit)Session["OapAudit"];
model.RigId = audit.RigId.ToString();
model.Title = "Audit Protocol";
model.ChecklistDateTime = DateTime.UtcNow;
var count = audit.OapAuditProtocols.Where(p => p.RigOapChecklist.OapchecklistId == model.OapchecklistId).Count();
var response = (count == 0) ? await OapAuditClient.AddProtocolToAuditAsync(audit.Id, model) : throw new Exception("Protocol Already Exists");
var protocols = OapAuditClient.GetAuditProtocolsAsync(audit.Id).Result?.Result?.Data;
return(TryCatchCollectionDisplayPartialView("ProtocolsToAuditPartial", "GenericDashBoardErrorsKey", () => protocols));
}
private void AssignReviewAndTasksToRigDPAs(RigOapChecklist checklist)
{
var checklistQuestionWithNoAnswers = from questions in checklist.Questions
from answers in questions.Answers
where answers.Value == "N"
select questions;
if (checklistQuestionWithNoAnswers.Any())
{
int rigId;
int.TryParse(adminCustomRepository.GetByName("RigId").Value, out rigId);
if (rigId == 0)
{
return;
}
var rigDPAs = dpaService.GetAllRigDPAs(rigId);
foreach (var dpa in rigDPAs)
{
irmaTaskService.Add(new IrmaTask()
{
Source = "Oap",
SourceId = checklist.Id.ToString(),
SourceUrl = string.Format("/Oap/MasterOversight/List/{0}", checklist.Id), // Needs improvement - Does not have access to the MVC routing from the api
AssigneeId = dpa.UserId,
Comment = string.Format("Master Oversight checklist {0} has a 'NO' answer that needs your review", checklist.RigChecklistUniqueId),
AssignedDateTime = DateTime.UtcNow,
Status = "Open"
});
reviewService.Add(new IrmaReview()
{
ReviewerPassportId = dpa.UserId,
RigId = rigId,
SourceForm = "Oap",
SourceFormId = checklist.Id.ToString(),
});
}
}
}
public static IList <OapCapaProtocolsFlatModel> ToFindingsCapaModel(this RigOapChecklist checkList, OapAuditClient auditClient, OapChecklistFindingClient checklistFindingClient)
{
var layoutList = new List <OapCapaProtocolsFlatModel>();
var ckListFindings = checklistFindingClient.GetAllFindingsForChecklistAsync(checkList.Id).Result?.Result?.Data;
foreach (var finding in ckListFindings)
{
var capa = checklistFindingClient.GetCAPAsByFindingIdAsync(finding.RigChecklistFindingInternalId).Result?.Result?.Data;
var capaProtocol = new OapCapaProtocolsFlatModel(checkList.Id, checkList.RigChecklistUniqueId, checkList.Assessors?.Where(a => a.IsLead == true)?.FirstOrDefault()?.User?.Name,
finding.RigChecklistFindingInternalId, finding.FindingTypeId, finding.FindingSubTypeId, finding.CriticalityId, 0, " "
, finding.AssignedUser?.Name, finding?.Status, "Review");
if (!layoutList.Any(l => l.FindingId == capaProtocol.FindingId))
{
layoutList.Add(capaProtocol);
}
}
return(layoutList);
}
public void Review(RigOapChecklist checklist, int userId, int order, string comment)
{
var verifier = checklist.VerifiedBy.ToList().FirstOrDefault(v => v.UserId == userId && v.Order == order);
if (verifier == null)
{
return;
}
// Update / close task
irmaTaskService.CloseTask("Oap - Workflow", checklist.RigChecklistUniqueId, userId);
verifier.SignedOn = DateTime.UtcNow;
verifier.UpdatedDateTime = DateTime.UtcNow;
verifier.Status = WorkflowStatus.Completed.ToString();
verifier.Comment = comment;
bool hasNextVerifier = checklist.VerifiedBy.ToList().OrderBy(v => v.Order).Any(v => v.Order > order);
if (hasNextVerifier == false)
{
checklist.Status = ChecklistStatus.Completed.ToString();
}
// Assign Task to Rig DPAs to review the checklist "No" answers
if (!hasNextVerifier && checklist.OapChecklist.Name.Contains("Master Oversight"))
{
AssignReviewAndTasksToRigDPAs(checklist);
AssignReviewAndTasksToOIM(checklist);
}
if (!hasNextVerifier && checklist.OapChecklist.Name.Contains("Audit Report"))
{
AssignReviewAndTasksToAuditOIM(checklist);
}
checklistRepository.Update(checklist);
}
public static void StartWorkflow(this RigOapChecklist rigOapChecklist, IRigOapChecklistWorkflowService rigOapChecklistWorkflowService, IWorkflowEngineService workflowEngineService, IWorkflowService workflowService, IPeopleService peopleService, ILog log, int ownerId)
{
var workflow = workflowService.GetActiveWorkflow(rigOapChecklist.OapChecklist.OapType.ChecklistLayoutId.Value);
//Create the Workflow Activity
var workflowActivity = workflow.GetActivity(rigOapChecklist.Id);
//Create the RigOapChecklistWorkflow instance
var rigChecklistWorkflow = new RigOapChecklistWorkflow(rigOapChecklist)
{
Name = $"Workflow Instance: {workflow.Name}",
Workflow = workflow
};
var version = new Version(workflow.Major, workflow.Minor);
//Start the Workflow Instance and All the store the instance details
//var login = Thread.CurrentPrincipal.Identity.Name;
workflowEngineService.Start(workflowActivity, version, rigChecklistWorkflow);
rigChecklistWorkflow.Id = rigOapChecklistWorkflowService.Add(rigChecklistWorkflow);
//var owner = PeopleService.GetByLogin(login);
//var owner = peopleService.Get(ownerId);
//Get the Current Principal And Assign Him to Workflow to
workflowEngineService.Process(workflowActivity, version, rigChecklistWorkflow, new AssignmentTransition("Assigned"), new AssignmentRequest()
{
Users = new List <AssignedUser> {
new AssignedUser()
{
UserId = ownerId, Role = "Owner"
}
}
});
}
public WebApiResult <RigOapChecklist> UpdateRigChecklist([FromBody] RigOapChecklist rigChecklist)
{
return(TryCatch <UpdateAuditProtocolRequest, RigOapChecklist>(new UpdateAuditProtocolRequest(rigChecklist)));
}
