public ActionResult UpdateChecklistHelp(OapChecklist model)
{
// TODO: Add update logic here
var response = OapChecklistClient.UpdateOapChecklistAsync(model).Result;
return(RedirectToAction("Index"));
}
private IEnumerable <OpenFSOGridModel> GetOpenFsoGridModelList(OapChecklist corpFSOChecklist)
{
IEnumerable <RigOapChecklist> checklists = GetOpenFsoChecklists(corpFSOChecklist);
List <OpenFSOGridModel> modelList = new List <OpenFSOGridModel>();
foreach (var checklist in checklists)
{
UserModel user = ServiceSystem.GetUser(checklist.OwnerId);
PositionModel position = ServiceSystem.GetUserPosition(checklist.OwnerId);
OpenFSOGridModel gridModel = new OpenFSOGridModel()
{
Id = checklist.Id,
Title = checklist.Title,
ChecklistDateTime = checklist.ChecklistDateTime,
RigChecklistUniqueId = checklist.RigChecklistUniqueId,
Observer = user?.DisplayName,
Position = position?.Name,
Company = user?.Company,
Location = user?.RigId
};
modelList.Add(gridModel);
}
return(modelList);
}
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);
}
private void AssignOwnerAsLeadAssessor(RigOapChecklist checklist, OapChecklist oapChecklist)
{
var ownerId = checklist.OwnerId;
var leadAssessor = new RigOapChecklistAssessor()
{
UserId = ownerId,
IsLead = true,
Role = VerifierRole.Assessor.ToString()
};
if (checklist.Assessors?.Any() == null)
{
checklist.Assessors = new List <RigOapChecklistAssessor>
{
leadAssessor
};
return;
}
var assessors = checklist.Assessors.ToList();
var assessor = assessors.FirstOrDefault(a => a.IsLead && a.UserId != ownerId);
if (assessor == null)
{
var order = (checklist.VerifiedBy.Any()) ? checklist.VerifiedBy?.Max(v => v.Order) ?? 0 : 0;
checklist.Assessors.Add(leadAssessor);
}
}
private void AddWorkInstructions(Guid rigOapChecklistId, string rigId, OapChecklist oapChecklist)
{
var plantSubgroupId = (from g in oapChecklist.Groups
from sg in g.SubGroups
where sg.IsWorkInstructions == true
select g.Id).FirstOrDefault();
if (plantSubgroupId <= 0)
{
return;
}
var oChecklistWorkInstructions = OapChecklistWorkInstructionRepository.GetAllWorkInstructionByChecklistAndRigId(rigId, oapChecklist.Id);
if (oChecklistWorkInstructions?.Any() == false)
{
return;
}
var rigWorkInstructions = (from wi in oChecklistWorkInstructions
select new RigOapChecklistWorkInstruction()
{
RigOapChecklistId = rigOapChecklistId,
WorkInstructionId = wi.Id
}).ToList();
rigWorkInstructions.ForEach(wi =>
{
RigOapChecklistWorkInstructionRepository.Add(wi);
});
}
public async Task <ActionResult> CreateChecklist(OapChecklist model)
{
// TODO: Add insert logic here
var response = await OapChecklistClient.AddOapChecklistAsync(model);
return(RedirectToAction("Index"));
}
public ActionResult IndexOpenChecklistsPartial()
{
OapChecklist corpFSOChecklist = GetCorporateFSOChecklist();
IEnumerable <OpenFSOGridModel> modelList = GetOpenFsoGridModelList(corpFSOChecklist);
return(PartialView("IndexOpenChecklistsPartial", modelList));
}
private void AddPlantMonitoringActivities(Guid rigOapChecklistId, OapChecklist oapChecklist)
{
var plantSubgroupId = (from g in oapChecklist.Groups
from sg in g.SubGroups
where sg.IsPlantMonitoring == true
select g.Id).FirstOrDefault();
if (plantSubgroupId <= 0)
{
return;
}
var oChecklistADM = OapChecklistAssetDataManagementRepository.GetAssetsByGroup(plantSubgroupId);
if (oChecklistADM?.Any() == false)
{
return;
}
var assets = (from oadm in oChecklistADM
select new RigOapChecklistGroupAsset()
{
RigOapChecklistId = rigOapChecklistId,
AssetId = oadm.Id
}).ToList();
assets.ForEach(a =>
{
RigOapChecklistGroupAssetRepository.Add(a);
});
}
private OapChecklist GetCorporateFSOChecklist()
{
if (corpFSOChecklist == null)
{
corpFSOChecklist = OapChecklistClient.GetByNameAsync("FSO Checklist").Result?.Result?.Data;
}
return(corpFSOChecklist);
}
public async Task <ActionResult> DeleteChecklist(OapChecklist model)
{
if (model.Id > 0)
{
var response = await OapChecklistClient.DeleteOapChecklistAsync(model.Id);
}
return(RedirectToAction("Index"));
}
public ActionResult TrainedObserversOnboard()
{
OapChecklist corpFSOChecklist = GetCorporateFSOChecklist();
List <TrainedObserversViewModel> trainedObservers = GetTrainedObservers(corpFSOChecklist);
ViewBag.TrainedObservers = trainedObservers;
return(PartialView("TrainedObserversOnboardPartial"));
}
public WebApiResult <bool> UpdateOapChecklist([FromBody] OapChecklist list)
{
if (list == null)
{
throw new System.Exception("Argument is null");
}
return(TryCatch <UpdateChecklistRequest, bool>(new UpdateChecklistRequest(list)));
}
private void AddQuestionsToChecklist(RigOapChecklist rigChecklist, OapChecklist oapChecklist)
{
if (
((rigChecklist.Questions == null) ||
((rigChecklist.Questions != null) && !rigChecklist.Questions.Any()))
&&
(rigChecklist.Questions == null && oapChecklist.Groups.Any(g => g.SubGroups.Any(sg => sg.Topics.Any(t => t.Questions.Any()))))
)
{
int answersCount = 1;
switch (oapChecklist.OapType.Code)
{
case "BAC":
answersCount = 7;
break;
case "OIM":
case "OM":
answersCount = 4;
break;
}
rigChecklist.Questions = (from groups in oapChecklist.Groups
from subGroups in groups.SubGroups
from topics in subGroups.Topics
from question in topics.Questions
where subGroups != null & topics != null && question != null
select new RigOapChecklistQuestion()
{
Id = Guid.NewGuid(),
RigOapChecklist = rigChecklist,
RigOapChecklistId = rigChecklist.Id,
OapChecklistQuestionId = question.Id,
OapChecklistQuestion = question,
Answers = GetAnswers(answersCount)
}).ToList();
if (oapChecklist.OapType.Code == "BAC")
{
var activeRigOapChecklistsWithNoAnswers = Repository.GetGetAllActiveChecklistsWithNoQuestions(rigChecklist.OapchecklistId);
ApplyBacNoControlLogic(rigChecklist, activeRigOapChecklistsWithNoAnswers);
var lastRigOapChecklist = Repository.GetLastChecklistWithQuestions(rigChecklist.OapchecklistId, rigChecklist.ChecklistDateTime);
ApplyBacNoControlLogic(rigChecklist, new List <RigOapChecklist>()
{
lastRigOapChecklist
});
}
}
}
private void AddCommentsToChecklist(RigOapChecklist rigChecklist, OapChecklist oapChecklist)
{
if (((rigChecklist.Comments == null) || ((rigChecklist.Comments != null) && !rigChecklist.Comments.Any())) && (rigChecklist.Questions == null && oapChecklist?.Comments != null))
{
rigChecklist.Comments = (from c in oapChecklist.Comments
select new RigOapChecklistComment()
{
Id = Guid.NewGuid(),
RigOapChecklist = rigChecklist,
RigOapChecklistId = rigChecklist.Id,
OapChecklistCommentId = c.Id,
OapChecklistComment = c
}).ToList();
}
}
// GET: IRMA/Fso
public override ActionResult Index()
{
OapChecklist corpFSOChecklist = GetCorporateFSOChecklist();
if (corpFSOChecklist == null)
{
ViewBag.CorpChecklistNull = "The definition of an FSO Checklist was not found in the system. Please create it in Corporate OAP first";
return(View("Index"));
}
IEnumerable <OpenFSOGridModel> modelList = GetOpenFsoGridModelList(corpFSOChecklist);
ViewBag.OpenChecklists = modelList;
List <TrainedObserversViewModel> trainedObservers = GetTrainedObservers(corpFSOChecklist);
ViewBag.TrainedObservers = trainedObservers;
return(View("Index"));
}
private IEnumerable <RigOapChecklist> GetOpenFsoChecklists(OapChecklist corpFSOChecklist)
{
return(RigOapChecklistClient.GetOpenFsoChecklistsAsync(corpFSOChecklist.Id).Result?.Result?.Data);
}
public WebApiResult <OapChecklist> AddOapChecklist([FromBody] OapChecklist list)
{
return(TryCatch <AddChecklistRequest, OapChecklist>(new AddChecklistRequest(list)));
}
public UpdateChecklistRequest(OapChecklist checklist)
{
Checklist = checklist;
}
private List <TrainedObserversViewModel> GetTrainedObservers(OapChecklist corpFSOChecklist)
{
IIrmaServiceDataModel pobDataModel = IrmaServiceSystem.GetServiceModel(IrmaConstants.IrmaPobModels.RigPersonnel); //.RigPersonnelHistory);
IEnumerable <RigPersonnelModel> currentPob = pobDataModel.GetItems("Status = 1", "Id").Cast <RigPersonnelModel>();
IEnumerable <RigOapChecklist> fsoChecklistsLast40Days =
RigOapChecklistClient.GetFsoChecklistByMinDateAsync(DateTime.Now.AddDays(-40).Date, corpFSOChecklist.Id).Result?.Result?.Data;
List <TrainedObserversViewModel> trainedObservers = new List <TrainedObserversViewModel>();
foreach (RigPersonnelModel person in currentPob)
{
UserModel userRecord = ServiceSystem.GetUser(person.PassportId);
if (userRecord == null || !person.DateStart.HasValue)
{
continue;
}
PositionModel position = ServiceSystem.GetUserPosition(person.PassportId);
TimeSpan timeOnBoard = DateTime.Now.Subtract(person.DateStart.Value);
TrainedObserversViewModel observer = new TrainedObserversViewModel()
{
Name = userRecord?.DisplayName,
Position = position?.Name,
DaysOnboard = timeOnBoard.Days
};
int numberOfObservations = 0;
IEnumerable <RigOapChecklist> checklistsWhileOnboard = fsoChecklistsLast40Days.Where(c => c.ChecklistDateTime >= person.DateStart);
DateTime?lastObservationDate = null;
foreach (RigOapChecklist fsoChecklist in checklistsWhileOnboard)
{
if (fsoChecklist.Assessors == null)
{
continue;
}
IEnumerable <RigOapChecklistAssessor> checklistParticipations = fsoChecklist.Assessors.Where(a => a.UserId == userRecord.Id);
numberOfObservations += checklistParticipations.Count();
if (checklistParticipations.Count() > 0 && (lastObservationDate == null || fsoChecklist.ChecklistDateTime > lastObservationDate))
{
lastObservationDate = fsoChecklist.ChecklistDateTime;
}
}
observer.LastObservation = lastObservationDate;
int weeksOnBoard = timeOnBoard.Days / 7;
bool isInCompliance = true;
if (timeOnBoard.Days > 7)
{
isInCompliance = numberOfObservations > 0 ? (numberOfObservations / weeksOnBoard >= 1) : false;
}
observer.Observations = numberOfObservations;
observer.IsInCompliance = isInCompliance;
trainedObservers.Add(observer);
}
return(trainedObservers);
}
private void ProcessBACChecklist(RigOapChecklist rigOapChecklist, OapChecklist oapChecklist)
{
AddPlantMonitoringActivities(rigOapChecklist.Id, oapChecklist);
// AddWorkInstructions(rigOapChecklist.Id, rigOapChecklist.RigId, oapChecklist);
AddReviewersToChecklist(rigOapChecklist);
}
