/// <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)); }