/// <summary>
/// Sets the md index ranges.
/// </summary>
/// <param name="dataObject">The data object.</param>
/// <param name="parser">The parser.</param>
/// <param name="force">if set to <c>true</c> force the index range update.</param>
protected override void SetIndexRange(MudLog dataObject, WitsmlQueryParser parser, bool force = true)
{
Logger.Debug("Set mudlog MD ranges.");
if (dataObject.GeologyInterval == null || dataObject.GeologyInterval.Count <= 0)
{
dataObject.StartMD = null;
dataObject.EndMD = null;
return;
}
SortGeologyIntervalData(dataObject.GeologyInterval);
var returnElements = parser.ReturnElements();
var alwaysInclude = force ||
OptionsIn.ReturnElements.All.Equals(returnElements) ||
OptionsIn.ReturnElements.HeaderOnly.Equals(returnElements);
if (alwaysInclude || parser.Contains("startMd"))
{
dataObject.StartMD = dataObject.GeologyInterval.First().MDTop;
}
if (alwaysInclude || parser.Contains("endMd"))
{
dataObject.EndMD = dataObject.GeologyInterval.Last().MDBottom;
}
}
public async Task MudLog141_PutObject_Can_Add_MudLog()
{
AddParents();
await RequestSessionAndAssert();
var handler = _client.Handler <IStoreCustomer>();
var uri = MudLog.GetUri();
var dataObject = CreateDataObject <MudLogList, MudLog>(uri, MudLog);
// Get Object Expecting it Not to Exist
await GetAndAssert(handler, uri, Energistics.Etp.EtpErrorCodes.NotFound);
// Put Object
await PutAndAssert(handler, dataObject);
// Get Object
var args = await GetAndAssert(handler, uri);
// Check Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var xml = args.Message.DataObject.GetString();
var result = Parse <MudLogList, MudLog>(xml);
Assert.IsNotNull(result);
}
protected override void PrepareData()
{
DevKit.Store.CapServerProviders = DevKit.Store.CapServerProviders
.Where(x => x.DataSchemaVersion == OptionsIn.DataVersion.Version131.Value)
.ToArray();
Well = new Well
{
Uid = DevKit.Uid(),
Name = DevKit.Name("Well"),
TimeZone = DevKit.TimeZone
};
Wellbore = new Wellbore
{
Uid = DevKit.Uid(),
Name = DevKit.Name("Wellbore"),
UidWell = Well.Uid,
NameWell = Well.Name,
MDCurrent = new MeasuredDepthCoord(0, MeasuredDepthUom.ft)
};
MudLog = new MudLog
{
Uid = DevKit.Uid(),
Name = DevKit.Name("MudLog"),
UidWell = Well.Uid,
NameWell = Well.Name,
UidWellbore = Wellbore.Uid,
NameWellbore = Wellbore.Name
};
QueryEmptyList = DevKit.List(new MudLog());
}
private static void Verify(MudLog mudLog)
{
if (string.IsNullOrEmpty(mudLog.Name))
{
throw new InvalidOperationException($"{nameof(mudLog.Name)} cannot be empty");
}
}
public async Task MudLog141_PutObject_Can_Add_MudLog()
{
AddParents();
await RequestSessionAndAssert();
var handler = _client.Handler <IStoreCustomer>();
var uri = MudLog.GetUri();
var dataObject = CreateDataObject <MudLogList, MudLog>(uri, MudLog);
// Get Object
var args = await GetAndAssert(handler, uri);
// Check for message flag indicating No Data
Assert.IsNotNull(args?.Header);
Assert.AreEqual((int)MessageFlags.NoData, args.Header.MessageFlags);
// Put Object
await PutAndAssert(handler, dataObject);
// Get Object
args = await GetAndAssert(handler, uri);
// Check Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var xml = args.Message.DataObject.GetString();
var result = Parse <MudLogList, MudLog>(xml);
Assert.IsNotNull(result);
}
public async Task <MudLog> GetMudLog(string wellUid, string wellboreUid, string mudlogUid)
{
var query = MudLogQueries.QueryById(wellUid, wellboreUid, mudlogUid);
var result = await WitsmlClient.GetFromStoreAsync(query, new OptionsIn(ReturnElements.All));
var witsmlMudLog = result.MudLogs.FirstOrDefault();
if (witsmlMudLog == null)
{
return(null);
}
var mudlog = new MudLog
{
Uid = witsmlMudLog.Uid,
Name = witsmlMudLog.Name,
WellUid = witsmlMudLog.UidWell,
WellName = witsmlMudLog.NameWell,
WellboreUid = witsmlMudLog.UidWellbore,
WellboreName = witsmlMudLog.NameWellbore,
StartMd = witsmlMudLog.StartMd?.Value,
EndMd = witsmlMudLog.EndMd?.Value,
GeologyInterval = GetGeologyIntervals(witsmlMudLog.GeologyInterval),
ItemState = witsmlMudLog.CommonData.ItemState,
DateTimeCreation = StringHelpers.ToDateTime(witsmlMudLog.CommonData.DTimCreation),
};
return(mudlog);
}
private static WitsmlMudLogs SetupMudLogToUpdate(MudLog mudLog)
{
var geologyIntervals = mudLog.GeologyInterval.Select(geologyInterval => new WitsmlMudLogGeologyInterval()
{
Uid = geologyInterval.Uid,
TypeLithology = geologyInterval.TypeLithology,
MdTop = new WitsmlIndex {
Uom = "m", Value = geologyInterval.MdTop
},
MdBottom = new WitsmlIndex {
Uom = "m", Value = geologyInterval.MdBottom
},
Lithology = new WitsmlMudLogLithology
{
Uid = geologyInterval.Lithology.Uid,
Type = geologyInterval.Lithology.Type,
CodeLith = geologyInterval.Lithology.CodeLith,
LithPc = new WitsmlIndex {
Uom = "%", Value = geologyInterval.Lithology.LithPc
}
},
CommonTime = new WitsmlCommonTime
{
DTimCreation = geologyInterval.CommonTime.DTimCreation?.ToString("yyyy-MM-ddTHH:mm:ssK.fffZ"),
DTimLastChange = geologyInterval.CommonTime.DTimLastChange?.ToString("yyyy-MM-ddTHH:mm:ssK.fffZ")
},
}).ToList();
return(new WitsmlMudLogs
{
MudLogs = new WitsmlMudLog
{
Uid = mudLog.Uid,
UidWellbore = mudLog.WellboreUid,
UidWell = mudLog.WellUid,
Name = mudLog.Name,
NameWellbore = mudLog.WellboreName,
NameWell = mudLog.WellName,
ObjectGrowing = mudLog.ObjectGrowing.ToString(),
MudLogCompany = mudLog.MudLogCompany,
MudLogEngineers = mudLog.MudLogEngineers,
StartMd = new WitsmlIndex {
Uom = "m", Value = mudLog.StartMd
},
EndMd = new WitsmlIndex {
Uom = "m", Value = mudLog.EndMd
},
GeologyInterval = geologyIntervals,
CommonData = new WitsmlCommonData
{
DTimCreation = mudLog.CommonData.DTimCreation?.ToString("yyyy-MM-ddTHH:mm:ssK.fffZ"),
DTimLastChange = mudLog.CommonData.DTimLastChange?.ToString("yyyy-MM-ddTHH:mm:ssK.fffZ"),
ItemState = mudLog.CommonData.ItemState,
SourceName = mudLog.CommonData.SourceName
}
}.AsSingletonList()
});
}
public async Task MudLog141_PutObject_Can_Update_MudLog()
{
AddParents();
await RequestSessionAndAssert();
var handler = _client.Handler <IStoreCustomer>();
var uri = MudLog.GetUri();
// Add a Comment to Data Object
MudLog.CommonData = new CommonData()
{
Comments = "Test PutObject"
};
var dataObject = CreateDataObject <MudLogList, MudLog>(uri, MudLog);
// Get Object Expecting it Not to Exist
await GetAndAssert(handler, uri, Energistics.Etp.EtpErrorCodes.NotFound);
// Put Object for Add
await PutAndAssert(handler, dataObject);
// Get Added Object
var args = await GetAndAssert(handler, uri);
// Check Added Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var xml = args.Message.DataObject.GetString();
var result = Parse <MudLogList, MudLog>(xml);
Assert.IsNotNull(result);
Assert.IsNotNull(result.CommonData.Comments);
// Remove Comment from Data Object
result.CommonData.Comments = null;
var updateDataObject = CreateDataObject <MudLogList, MudLog>(uri, result);
// Put Object for Update
await PutAndAssert(handler, updateDataObject);
// Get Updated Object
args = await GetAndAssert(handler, uri);
// Check Added Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var updateXml = args.Message.DataObject.GetString();
result = Parse <MudLogList, MudLog>(updateXml);
Assert.IsNotNull(result);
// Test Data Object overwrite
Assert.IsNull(result.CommonData.Comments);
}
/// <summary>
/// Filters the geology interval data with the query structural range.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="parser">The parser.</param>
protected override void FilterGeologyIntervalData(MudLog entity, WitsmlQueryParser parser)
{
if (!entity.GeologyInterval.Any())
{
return;
}
var range = GetQueryIndexRange(parser);
entity.GeologyInterval.RemoveAll(s => WithinRange(s.MDTop.Value, range));
}
/// <summary>
/// Filters the geology interval data based on query parameters.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="geologyIntervals">The mudlog geology intervals.</param>
/// <param name="parser">The parser.</param>
/// <param name="context">The query context.</param>
/// <returns>The count of mudlog geology intervals after filtering.</returns>
protected override int FilterGeologyIntervalData(MudLog entity, List <GeologyInterval> geologyIntervals, WitsmlQueryParser parser = null, IQueryContext context = null)
{
if (geologyIntervals == null || geologyIntervals.Count == 0)
{
return(0);
}
var range = GetQueryIndexRange(parser);
var maxDataNodes = context?.MaxDataNodes;
switch (parser?.IntervalRangeInclusion())
{
default:
entity.GeologyInterval = range.Start.HasValue
? range.End.HasValue
? geologyIntervals.Where(s => s.MDTop.Value >= range.Start.Value && s.MDTop.Value <= range.End.Value).ToList()
: geologyIntervals.Where(s => s.MDTop.Value >= range.Start.Value).ToList()
: range.End.HasValue
? geologyIntervals.Where(s => s.MDTop.Value <= range.End.Value).ToList()
: geologyIntervals;
break;
case "whole-interval":
entity.GeologyInterval = range.Start.HasValue
? range.End.HasValue
? geologyIntervals.Where(s => s.MDTop.Value >= range.Start.Value && s.MDBottom.Value <= range.End.Value).ToList()
: geologyIntervals.Where(s => s.MDTop.Value >= range.Start.Value).ToList()
: range.End.HasValue
? geologyIntervals.Where(s => s.MDBottom.Value <= range.End.Value).ToList()
: geologyIntervals;
break;
case "any-part":
entity.GeologyInterval = range.Start.HasValue
? range.End.HasValue
? geologyIntervals.Where(s => s.MDBottom.Value >= range.Start.Value && s.MDTop.Value <= range.End.Value).ToList()
: geologyIntervals.Where(s => s.MDBottom.Value >= range.Start.Value).ToList()
: range.End.HasValue
? geologyIntervals.Where(s => s.MDBottom.Value <= range.End.Value).ToList()
: geologyIntervals;
break;
}
SortGeologyIntervalData(entity.GeologyInterval);
if (maxDataNodes != null && entity.GeologyInterval.Count > maxDataNodes.Value)
{
Logger.Debug($"Truncating mudlog geology intervals with {entity.GeologyInterval.Count}.");
entity.GeologyInterval = entity.GeologyInterval.GetRange(0, maxDataNodes.Value);
context.DataTruncated = true;
}
return(entity.GeologyInterval.Count);
}
public async Task MudLog141_GetResources_Can_Get_All_MudLog_Resources()
{
AddParents();
DevKit.AddAndAssert <MudLogList, MudLog>(MudLog);
await RequestSessionAndAssert();
var uri = MudLog.GetUri();
var parentUri = uri.Parent;
await GetResourcesAndAssert(parentUri);
var folderUri = parentUri.Append(uri.ObjectType);
await GetResourcesAndAssert(folderUri);
}
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();
}
}
public void TestSetUp()
{
Logger.Debug($"Executing {TestContext.TestName}");
DevKit = new DevKit141Aspect(TestContext);
DevKit.Store.CapServerProviders = DevKit.Store.CapServerProviders
.Where(x => x.DataSchemaVersion == OptionsIn.DataVersion.Version141.Value)
.ToArray();
Well = new Well
{
Uid = DevKit.Uid(),
Name = DevKit.Name("Well"),
TimeZone = DevKit.TimeZone
};
Wellbore = new Wellbore
{
Uid = DevKit.Uid(),
Name = DevKit.Name("Wellbore"),
UidWell = Well.Uid,
NameWell = Well.Name,
MD = new MeasuredDepthCoord(0, MeasuredDepthUom.ft)
};
MudLog = new MudLog
{
Uid = DevKit.Uid(),
Name = DevKit.Name("MudLog"),
UidWell = Well.Uid,
NameWell = Well.Name,
UidWellbore = Wellbore.Uid,
NameWellbore = Wellbore.Name
};
QueryEmptyList = DevKit.List(new MudLog());
BeforeEachTest();
OnTestSetUp();
}
public void MudLog141DataAdapter_GetFromStore_Get_Range_With_StartMD()
{
AddParents();
MudLog.GeologyInterval = DevKit.MudLogGenerator.GenerateGeologyIntervals(5, 10.0);
DevKit.AddAndAssert(MudLog);
var query = new MudLog()
{
Uid = MudLog.Uid,
UidWell = MudLog.UidWell,
UidWellbore = MudLog.UidWellbore,
StartMD = new MeasuredDepthCoord(160, MeasuredDepthUom.ft)
};
var result = DevKit.GetAndAssert(query, queryByExample: true);
Assert.IsNotNull(result);
Assert.AreEqual(MudLog.Uid, result.Uid);
Assert.AreEqual(160, result.StartMD.Value);
Assert.AreEqual(260, result.EndMD.Value);
Assert.AreEqual(2, result.GeologyInterval.Count);
}
/// <summary>
/// Adds mudLog object and test the return code
/// </summary>
/// <param name="mudLog">the mudLog</param>
/// <param name="errorCode">the errorCode</param>
public WMLS_AddToStoreResponse AddAndAssert(MudLog mudLog, ErrorCodes errorCode = ErrorCodes.Success)
{
return(AddAndAssert <MudLogList, MudLog>(mudLog, errorCode));
}
/// <summary>
/// Sets additional default values for the specified data object.
/// </summary>
/// <param name="dataObject">The data object.</param>
partial void SetAdditionalDefaultValues(MudLog dataObject)
{
// Ensure ObjectGrowing is false during AddToStore
dataObject.ObjectGrowing = false;
}
public async Task MudLog141_PutObject_Can_Update_MudLog()
{
AddParents();
await RequestSessionAndAssert();
var handler = _client.Handler <IStoreCustomer>();
var uri = MudLog.GetUri();
// Add a Comment to Data Object
MudLog.CommonData = new CommonData()
{
Comments = "Test PutObject"
};
var dataObject = CreateDataObject <MudLogList, MudLog>(uri, MudLog);
// Get Object
var args = await GetAndAssert(handler, uri);
// Check for message flag indicating No Data
Assert.IsNotNull(args?.Header);
Assert.AreEqual((int)MessageFlags.NoData, args.Header.MessageFlags);
// Put Object for Add
await PutAndAssert(handler, dataObject);
// Get Added Object
args = await GetAndAssert(handler, uri);
// Check Added Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var xml = args.Message.DataObject.GetString();
var result = Parse <MudLogList, MudLog>(xml);
Assert.IsNotNull(result);
Assert.IsNotNull(result.CommonData.Comments);
// Remove Comment from Data Object
result.CommonData.Comments = null;
var updateDataObject = CreateDataObject <MudLogList, MudLog>(uri, result);
// Put Object for Update
await PutAndAssert(handler, updateDataObject);
// Get Updated Object
args = await GetAndAssert(handler, uri);
// Check Added Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var updateXml = args.Message.DataObject.GetString();
result = Parse <MudLogList, MudLog>(updateXml);
Assert.IsNotNull(result);
// Test Data Object overwrite
Assert.IsNull(result.CommonData.Comments);
}
/// <summary>
/// Formats the mudlog geology interval data.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="parser">The query parser.</param>
/// <returns>A collection of formatted mudlog geology intervals.</returns>
protected override List <GeologyInterval> FormatGeologyIntervalData(MudLog entity, WitsmlQueryParser parser)
{
entity.GeologyInterval = base.FormatGeologyIntervalData(entity, parser);
return(entity.GeologyInterval);
}
/// <summary>
/// Determines whether the objectGrowing flag is true for the specified entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns>
/// <c>true</c> if the objectGrowing flag is true for the specified entity; otherwise, <c>false</c>.
/// </returns>
protected override bool IsObjectGrowing(MudLog entity)
{
return(entity.ObjectGrowing.GetValueOrDefault());
}
/// <summary>
/// Clears the mudlog geology intervals.
/// </summary>
/// <param name="entity">The entity.</param>
protected override void ClearGeologyIntervals(MudLog entity)
{
entity.GeologyInterval = null;
}
/// <summary>
/// Sets the mudlog geology intervals.
/// </summary>
/// <param name="dataObject">The mudlog data object.</param>
/// <param name="geologyIntervals">The mudlog geology intervals.</param>
/// <returns>The mudlog.</returns>
protected override MudLog SetGeologyIntervals(MudLog dataObject, List <GeologyInterval> geologyIntervals)
{
dataObject.GeologyInterval = geologyIntervals;
return(dataObject);
}
/// <summary>
/// Does UpdateInStore on mudLog object and test the return code
/// </summary>
/// <param name="mudLog">the mudLog</param>
/// <param name="errorCode">The error code.</param>
public void UpdateAndAssert(MudLog mudLog, ErrorCodes errorCode = ErrorCodes.Success)
{
UpdateAndAssert <MudLogList, MudLog>(mudLog, errorCode);
}
/// <summary>
/// Check if need to query mongo file for geology interval data.
/// </summary>
/// <param name="entity">The result data object.</param>
/// <param name="header">The full header object.</param>
/// <returns><c>true</c> if needs to query mongo file; otherwise, <c>false</c>.</returns>
protected override bool IsQueryingGeologyIntervalFile(MudLog entity, MudLog header)
{
return(header.StartMD != null && entity.GeologyInterval == null);
}
/// <summary>
/// Gets the mudlog geology intervals.
/// </summary>
/// <param name="dataObject">The mudlog data object.</param>
/// <returns>The mudlog geology intervals collection.</returns>
protected override List <GeologyInterval> GetGeologyIntervals(MudLog dataObject)
{
return(dataObject.GeologyInterval);
}
/// <summary>
/// Does get query for single mudLog object and test for result count equal to 1 and is not null
/// </summary>
/// <param name="mudLog">the mudLog with UIDs for well and wellbore</param>
/// <param name="isNotNull">if set to <c>true</c> the result should not be null.</param>
/// <param name="optionsIn">The options in.</param>
/// <param name="queryByExample">if set to <c>true</c> query by example.</param>
/// <returns>The first wbGeometry from the response</returns>
public MudLog GetAndAssert(MudLog mudLog, bool isNotNull = true, string optionsIn = null, bool queryByExample = false)
{
return(GetAndAssert <MudLogList, MudLog>(mudLog, isNotNull, optionsIn, queryByExample));
}
