private async Task <WitsmlLog> GetLogHeader(string wellUid, string wellboreUid, string logUid)
{
var query = LogQueries.GetWitsmlLogById(wellUid, wellboreUid, logUid);
var result = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.HeaderOnly));
return(result.Logs.FirstOrDefault());
}
public override async Task <(WorkerResult, RefreshAction)> Execute(DeleteRiskJob job)
{
var wellUid = job.RiskReference.WellUid;
var wellboreUid = job.RiskReference.WellboreUid;
var uid = job.RiskReference.Uid;
var deleteRequest = RiskQueries.DeleteRiskQuery(wellUid, wellboreUid, uid);
var result = await witsmlClient.DeleteFromStoreAsync(deleteRequest);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var refreshAction = new RefreshWell(witsmlClient.GetServerHostname(), wellUid, RefreshType.Remove);
var workerResult = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Deleted well with uid ${wellUid}");
return(workerResult, refreshAction);
}
Log.Error("Failed to delete risk. WellUid: {WellUid}", wellUid);
var query = RiskQueries.QueryById(wellUid, wellboreUid, uid);
var queryResult = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.IdOnly));
EntityDescription description = null;
var risk = queryResult.Risks.FirstOrDefault();
if (risk != null)
{
description = new EntityDescription
{
ObjectName = risk.Name
};
}
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to delete risk", result.Reason, description), null);
}
private static async Task <WitsmlWellbore> GetWellbore(IWitsmlClient client, WellboreReference wellboreReference)
{
var query = WellboreQueries.QueryByUid(wellboreReference.WellUid, wellboreReference.WellboreUid);
var wellbores = await client.GetFromStoreAsync(query, OptionsIn.Requested);
return(!wellbores.Wellbores.Any() ? null : wellbores.Wellbores.First());
}
private async Task <WitsmlLog> GetLog(IWitsmlClient client, LogReference logReference)
{
var logQuery = LogQueries.QueryById(logReference.WellUid, logReference.WellboreUid, logReference.LogUid);
var logs = await client.GetFromStoreAsync(logQuery, OptionsIn.HeaderOnly);
return(!logs.Logs.Any() ? null : logs.Logs.First());
}
public override async Task <(WorkerResult, RefreshAction)> Execute(ModifyWellJob job)
{
Verify(job.Well);
var wellUid = job.Well.Uid;
var wellName = job.Well.Name;
var witsmlWellToUpdate = WellQueries.UpdateWitsmlWell(job.Well);
var result = await witsmlClient.UpdateInStoreAsync(witsmlWellToUpdate);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var workerResult = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Well updated ({wellName} [{wellUid}])");
var refreshAction = new RefreshWell(witsmlClient.GetServerHostname(), job.Well.Uid, RefreshType.Update);
return(workerResult, refreshAction);
}
var updatedWells = await witsmlClient.GetFromStoreAsync(witsmlWellToUpdate, new OptionsIn(ReturnElements.IdOnly));
var updatedWell = updatedWells.Wells.First();
var description = new EntityDescription
{
WellName = updatedWell.Name
};
Log.Error("Job failed. An error occurred when modifying well: {Well}", job.Well.PrintProperties());
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to update well", result.Reason, description), null);
}
private static async Task <WitsmlWellbore> GetWellbore(IWitsmlClient client, LogObject logObject)
{
var query = WellboreQueries.GetWitsmlWellboreByUid(logObject.WellUid, logObject.WellboreUid);
var wellbores = await client.GetFromStoreAsync(query, new OptionsIn(ReturnElements.Requested));
return(!wellbores.Wellbores.Any() ? null : wellbores.Wellbores.First());
}
private static async Task <WitsmlLog> GetLog(IWitsmlClient client, LogReference logReference)
{
var logQuery = LogQueries.QueryById(logReference.WellUid, logReference.WellboreUid, logReference.LogUid);
var result = await client.GetFromStoreAsync(logQuery, OptionsIn.All);
return(!result.Logs.Any() ? null : result.Logs.First());
}
public async Task <(WorkerResult, RefreshAction)> Execute(ModifyWellboreJob job)
{
Verify(job.Wellbore);
var wellUid = job.Wellbore.WellUid;
var wellboreUid = job.Wellbore.Uid;
var query = WellboreQueries.UpdateWellboreQuery(wellUid, wellboreUid);
var wellbore = query.Wellbores.First();
wellbore.Name = job.Wellbore.Name;
wellbore.PurposeWellbore = job.Wellbore.WellborePurpose;
var result = await witsmlClient.UpdateInStoreAsync(query);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var workerResult = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Wellbore updated ({wellbore.Name} [{wellbore.Uid}])");
var refreshAction = new RefreshWellbore(witsmlClient.GetServerHostname(), job.Wellbore.WellUid, job.Wellbore.Uid, RefreshType.Update);
return(workerResult, refreshAction);
}
var updatedWellbores = await witsmlClient.GetFromStoreAsync(query, OptionsIn.IdOnly);
var updatedWellbore = updatedWellbores.Wellbores.First();
var description = new EntityDescription
{
WellName = updatedWellbore.NameWell,
WellboreName = updatedWellbore.Name
};
Log.Error($"Job failed. An error occurred when modifying wellbore: {job.Wellbore.PrintProperties()}");
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to update wellbore", result.Reason, description), null);
}
private async Task <string> ExecuteQuery(string queryFile, string returnElements, int?maxReturnNodes)
{
var queryPath = Path.Combine(Directory.GetCurrentDirectory(), queryFile);
var query = await File.ReadAllTextAsync(queryPath);
var returnElementsEnum = EnumParser <ReturnElements> .GetEnum(returnElements);
var optionsIn = new OptionsIn(returnElementsEnum, maxReturnNodes);
return(await witsmlClient.GetFromStoreAsync(query, optionsIn));
}
private async Task <IList <WitsmlLog> > GetLogs(string wellUid, string wellboreUid)
{
var query = new WitsmlLogs
{
Logs = new WitsmlLog
{
UidWell = wellUid,
UidWellbore = wellboreUid
}.AsSingletonList()
};
var result = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.HeaderOnly));
return(result?.Logs);
}
private async Task <WitsmlTubular> GetTubular(string wellUid, string wellboreUid, string tubularUid)
{
var query = new WitsmlTubulars
{
Tubulars = new WitsmlTubular
{
Uid = tubularUid,
UidWell = wellUid,
UidWellbore = wellboreUid
}.AsSingletonList()
};
var result = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.All));
return(result?.Tubulars.FirstOrDefault());
}
private async Task WaitUntilWellboreHasBeenCreated(Wellbore wellbore)
{
var isWellboreCreated = false;
var query = WellboreQueries.QueryByUid(wellbore.WellUid, wellbore.Uid);
var maxRetries = 30;
while (!isWellboreCreated)
{
if (--maxRetries == 0)
{
throw new InvalidOperationException($"Not able to read newly created wellbore with name {wellbore.Name} (id={wellbore.Uid})");
}
Thread.Sleep(1000);
var wellboreResult = await witsmlClient.GetFromStoreAsync(query, OptionsIn.IdOnly);
isWellboreCreated = wellboreResult.Wellbores.Any();
}
}
private async Task WaitUntilRiskHasBeenCreated(Risk risk)
{
var isCreated = false;
var query = RiskQueries.QueryById(risk.UidWell, risk.UidWellbore, risk.Uid);
var maxRetries = 30;
while (!isCreated)
{
if (--maxRetries == 0)
{
throw new InvalidOperationException($"Not able to read newly created Risk with name {risk.Name} (id={risk.Uid})");
}
Thread.Sleep(1000);
var riskResult = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.IdOnly));
isCreated = riskResult.Risks.Any();
}
}
private async Task WaitUntilMudLogHasBeenCreated(MudLog mudLog)
{
var isMudLogCreated = false;
var query = MudLogQueries.QueryById(mudLog.WellUid, mudLog.WellboreUid, mudLog.Uid);
var maxRetries = 30;
while (!isMudLogCreated)
{
if (--maxRetries == 0)
{
throw new InvalidOperationException($"Not able to read newly created MudLog with name {mudLog.Name} (id={mudLog.Uid})");
}
Thread.Sleep(1000);
var mudLogResult = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.IdOnly));
isMudLogCreated = mudLogResult.MudLogs.Any();
}
}
private async Task WaitUntilWellHasBeenCreated(Well well)
{
var isWellCreated = false;
var query = WellQueries.GetWitsmlWellByUid(well.Uid);
var maxRetries = 30;
while (!isWellCreated)
{
if (--maxRetries == 0)
{
throw new InvalidOperationException($"Not able to read newly created well with name {well.Name} (id={well.Uid})");
}
Thread.Sleep(1000);
var wellResult = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.IdOnly));
isWellCreated = wellResult.Wells.Any();
}
}
public async Task <(WorkerResult, RefreshAction)> Execute(ModifyLogObjectJob job)
{
Verify(job.LogObject);
var wellUid = job.LogObject.WellUid;
var wellboreUid = job.LogObject.WellboreUid;
var logUid = job.LogObject.Uid;
var query = CreateRequest(wellUid, wellboreUid, logUid,
new WitsmlLog
{
Uid = logUid,
UidWell = wellUid,
UidWellbore = wellboreUid,
Name = job.LogObject.Name
});
var result = await witsmlClient.UpdateInStoreAsync(query);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var refreshAction = new RefreshWellbore(witsmlClient.GetServerHostname(), wellUid, wellboreUid, RefreshType.Update);
return(new WorkerResult(witsmlClient.GetServerHostname(), true, $"Log updated ({job.LogObject.Name} [{logUid}])"), refreshAction);
}
Log.Error($"Job failed. An error occurred when modifying logobject: {job.LogObject.PrintProperties()}");
var logQuery = LogQueries.QueryById(wellUid, wellboreUid, logUid);
var logs = await witsmlClient.GetFromStoreAsync(logQuery, OptionsIn.IdOnly);
var log = logs.Logs.FirstOrDefault();
EntityDescription description = null;
if (log != null)
{
description = new EntityDescription
{
WellName = log.NameWell,
WellboreName = log.NameWellbore,
ObjectName = log.Name
};
}
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to update log", result.Reason, description), null);
}
public override async Task <(WorkerResult, RefreshAction)> Execute(DeleteMnemonicsJob job)
{
var wellUid = job.LogObject.WellUid;
var wellboreUid = job.LogObject.WellboreUid;
var logUid = job.LogObject.LogUid;
var mnemonics = new ReadOnlyCollection <string>(job.Mnemonics.ToList());
var mnemonicsString = string.Join(", ", mnemonics);
var query = LogQueries.DeleteMnemonics(wellUid, wellboreUid, logUid, mnemonics);
var result = await witsmlClient.DeleteFromStoreAsync(query);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var refreshAction = new RefreshLogObject(witsmlClient.GetServerHostname(), wellUid, wellboreUid, logUid, RefreshType.Update);
var workerResult = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Deleted mnemonics: {mnemonicsString} for log: {logUid}");
return(workerResult, refreshAction);
}
Log.Error("Failed to delete mnemonics for log object. WellUid: {WellUid}, WellboreUid: {WellboreUid}, Uid: {LogUid}, Mnemonics: {MnemonicsString}",
wellUid,
wellboreUid,
logUid,
mnemonics);
query = LogQueries.GetWitsmlLogById(wellUid, wellboreUid, logUid);
var queryResult = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.IdOnly));
var log = queryResult.Logs.First();
EntityDescription description = null;
if (log != null)
{
description = new EntityDescription
{
WellName = log.NameWell,
WellboreName = log.NameWellbore,
ObjectName = log.Name
};
}
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to delete mnemonics", result.Reason, description), null);
}
private async Task <WitsmlLog> GetLogHeader(string wellUid, string wellboreUid, string logUid)
{
var query = new WitsmlLogs
{
Logs = new List <WitsmlLog>
{
new()
{
Uid = logUid,
UidWell = wellUid,
UidWellbore = wellboreUid
}
}
};
var result = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.HeaderOnly));
return(result?.Logs.FirstOrDefault());
}
private async IAsyncEnumerable <WitsmlWellbore> GetActiveWellbores()
{
var liveLogsQuery = new WitsmlLogs
{
Logs = new WitsmlLog
{
Uid = "",
UidWell = "",
UidWellbore = "",
Name = "",
NameWell = "",
NameWellbore = "",
ObjectGrowing = "true"
}.AsSingletonList()
};
var result = await witsmlClient.GetFromStoreAsync(liveLogsQuery, new OptionsIn(ReturnElements.Requested));
var groupedResults = result.Logs
.OrderBy(x => x.NameWell)
.GroupBy(x => new { x.UidWell, x.UidWellbore })
.Select(x => new
{
x.Key.UidWell,
x.Key.UidWellbore,
Logs = x
});
foreach (var groupedResult in groupedResults)
{
yield return(new WitsmlWellbore
{
UidWell = groupedResult.UidWell,
Uid = groupedResult.UidWellbore,
NameWell = groupedResult.Logs.First().NameWell,
Name = groupedResult.Logs.First().NameWellbore
});
}
}
public override async Task <(WorkerResult, RefreshAction)> Execute(DeleteTrajectoryJob job)
{
var wellUid = job.TrajectoryReference.WellUid;
var wellboreUid = job.TrajectoryReference.WellboreUid;
var trajectoryUid = job.TrajectoryReference.TrajectoryUid;
var witsmlTrajectory = TrajectoryQueries.GetWitsmlTrajectoryById(wellUid, wellboreUid, trajectoryUid);
var result = await witsmlClient.DeleteFromStoreAsync(witsmlTrajectory);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful", GetType().Name);
var refreshAction = new RefreshWellbore(witsmlClient.GetServerHostname(), wellUid, wellboreUid, RefreshType.Update);
return(new WorkerResult(witsmlClient.GetServerHostname(), true, $"Deleted trajectory: ${trajectoryUid}"), refreshAction);
}
Log.Error("Failed to delete trajectory. WellUid: {WellUid}, WellboreUid: {WellboreUid}, Uid: {TrajectoryUid}",
wellUid,
wellboreUid,
trajectoryUid);
witsmlTrajectory = TrajectoryQueries.GetWitsmlTrajectoryById(wellUid, wellboreUid, trajectoryUid);
var queryResult = await witsmlClient.GetFromStoreAsync(witsmlTrajectory, new OptionsIn(ReturnElements.IdOnly));
var trajectory = queryResult.Trajectories.First();
EntityDescription description = null;
if (trajectory != null)
{
description = new EntityDescription
{
WellName = trajectory.NameWell,
WellboreName = trajectory.NameWellbore,
ObjectName = trajectory.Name
};
}
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to delete trajectory", result.Reason, description), null);
}
public async Task <(WorkerResult, RefreshWellbore)> Execute(DeleteWellboreJob job)
{
var wellUid = job.WellboreReference.WellUid;
var wellboreUid = job.WellboreReference.WellboreUid;
var query = WellboreQueries.DeleteWellboreQuery(wellUid, wellboreUid);
var result = await witsmlClient.DeleteFromStoreAsync(query);
if (result.IsSuccessful)
{
Log.Information("{JobType} - Job successful.", GetType().Name);
var refreshAction = new RefreshWellbore(witsmlClient.GetServerHostname(), wellUid, wellboreUid, RefreshType.Remove);
var workerResult = new WorkerResult(witsmlClient.GetServerHostname(), true, $"Deleted wellbore: ${wellboreUid}");
return(workerResult, refreshAction);
}
Log.Error("Failed to delete wellbore. WellUid: {WellUid}, WellboreUid: {WellboreUid}",
wellUid,
wellboreUid);
query = WellboreQueries.QueryByUid(wellUid, wellboreUid);
var queryResult = await witsmlClient.GetFromStoreAsync(query, OptionsIn.IdOnly);
EntityDescription description = null;
var wellbore = queryResult.Wellbores.FirstOrDefault();
if (wellbore != null)
{
description = new EntityDescription
{
WellName = wellbore.NameWell,
ObjectName = wellbore.Name
};
}
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to delete wellbore", result.Reason, description), null);
}
private async Task <IEnumerable <WitsmlTubular> > GetTubulars(string wellUid, string wellboreUid)
{
var query = new WitsmlTubulars
{
Tubulars = new WitsmlTubular
{
UidWell = wellUid,
UidWellbore = wellboreUid,
Uid = "",
NameWell = "",
NameWellbore = "",
Name = "",
TypeTubularAssy = "",
CommonData = new WitsmlCommonData
{
DTimLastChange = ""
}
}.AsSingletonList()
};
var result = await witsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.Requested));
return(result?.Tubulars);
}
public async Task <(WorkerResult, RefreshAction)> Execute(TrimLogDataJob job)
{
var witsmlLogQuery = LogQueries.QueryById(job.LogObject.WellUid, job.LogObject.WellboreUid, job.LogObject.LogUid);
var witsmlLogs = await witsmlClient.GetFromStoreAsync(witsmlLogQuery, OptionsIn.HeaderOnly);
var witsmlLog = witsmlLogs.Logs.First();
var currentStartIndex = Index.Start(witsmlLog);
var newStartIndex = Index.Start(witsmlLog, job.StartIndex);
var currentEndIndex = Index.End(witsmlLog);
var newEndIndex = Index.End(witsmlLog, job.EndIndex);
bool trimmedStartOfLog = false;
if (currentStartIndex < newStartIndex && newStartIndex < currentEndIndex)
{
var trimLogObjectStartQuery = CreateRequest(
job.LogObject.WellUid,
job.LogObject.WellboreUid,
job.LogObject.LogUid,
witsmlLog.IndexType,
deleteTo: newStartIndex);
var result = await witsmlClient.DeleteFromStoreAsync(trimLogObjectStartQuery);
if (result.IsSuccessful)
{
trimmedStartOfLog = true;
}
else
{
Log.Error($"Job failed. An error occurred when trimming logobject start: {job.PrintProperties()}");
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to update start of log", result.Reason, GetDescription(witsmlLog)), null);
}
}
bool trimmedEndOfLog = false;
if (currentEndIndex > newEndIndex && newEndIndex > currentStartIndex)
{
var trimLogObjectEndQuery = CreateRequest(
job.LogObject.WellUid,
job.LogObject.WellboreUid,
job.LogObject.LogUid,
witsmlLog.IndexType,
deleteFrom: newEndIndex);
var result = await witsmlClient.DeleteFromStoreAsync(trimLogObjectEndQuery);
if (result.IsSuccessful)
{
trimmedEndOfLog = true;
}
else
{
Log.Error($"Job failed. An error occurred when trimming logobject end: {job.PrintProperties()}");
return(new WorkerResult(witsmlClient.GetServerHostname(), false, "Failed to update end of log", result.Reason, GetDescription(witsmlLog)), null);
}
}
var refreshAction = new RefreshLogObject(witsmlClient.GetServerHostname(), job.LogObject.WellUid, job.LogObject.WellboreUid, job.LogObject.LogUid, RefreshType.Update);
if (trimmedStartOfLog && trimmedEndOfLog)
{
return(new WorkerResult(witsmlClient.GetServerHostname(), true, $"Updated start/end of log [{job.LogObject.LogUid}]"), refreshAction);
}
if (trimmedStartOfLog)
{
return(new WorkerResult(witsmlClient.GetServerHostname(), true, $"Updated start of log [{job.LogObject.LogUid}]"), refreshAction);
}
if (trimmedEndOfLog)
{
return(new WorkerResult(witsmlClient.GetServerHostname(), true, $"Updated end of log [{job.LogObject.LogUid}]"), refreshAction);
}
return(new WorkerResult(witsmlClient.GetServerHostname(), false, $"Failed to update start/end of log [{job.LogObject.LogUid}]", "Invalid index range"), null);
}