/// <summary>
/// Called when a data object is selected.
/// </summary>
private void OnDataObjectSelected()
{
if (DataObject == null || DataObject == QueryTemplateText)
{
return;
}
var type = ObjectTypes.GetObjectGroupType(DataObject, Model.WitsmlVersion);
var query = Proxy.BuildEmtpyQuery(type, Model.WitsmlVersion);
XmlQuery.SetText(WitsmlParser.ToXml(query));
}
private static TrajectoryStation GetTrajectoryStation(DataObject dataObjectGet)
{
if (dataObjectGet.Data == null)
{
return(null);
}
var growingPartXml = dataObjectGet.GetString();
var trajectoryStationObject = WitsmlParser.Parse <TrajectoryStation>(WitsmlParser.Parse(growingPartXml).Root);
return(trajectoryStationObject);
}
/// <summary>
/// Updates the growing data object query.
/// </summary>
/// <param name="xmlOut">The XML out.</param>
/// <returns>The updated growing data object query.</returns>
public string UpdateDataQuery(string xmlOut)
{
var queryDoc = WitsmlParser.Parse(QueryIn);
var resultDoc = WitsmlParser.Parse(xmlOut);
if (ObjectTypes.Log.EqualsIgnoreCase(ObjectType))
{
return(UpdateLogDataQuery(queryDoc, resultDoc));
}
return(string.Empty);
}
/// <summary>
/// Validates the array element.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="properties">The properties.</param>
/// <param name="isAdd">if set to <c>true</c> [is add].</param>
/// <exception cref="WitsmlException">The Witsml exception with specified error code.</exception>
protected void ValidateArrayElement(XElement element, IList <PropertyInfo> properties, bool isAdd = true)
{
Logger.DebugFormat($"Validating array element: {element.Name.LocalName}");
if (isAdd)
{
WitsmlParser.RemoveEmptyElements(element);
if (!element.HasElements)
{
throw new WitsmlException(ErrorCodes.EmptyNewElementsOrAttributes);
}
}
else
{
var emptyElements = element.Elements()
.Where(e => e.IsEmpty || string.IsNullOrWhiteSpace(e.Value))
.ToList();
foreach (var child in emptyElements)
{
var prop = GetPropertyInfoForAnElement(properties, child.Name.LocalName);
if (prop == null)
{
continue;
}
if (prop.IsDefined(typeof(RequiredAttribute), false))
{
throw new WitsmlException(ErrorCodes.EmptyNewElementsOrAttributes);
}
}
var emptyAttributes = element.Attributes()
.Where(a => string.IsNullOrWhiteSpace(a.Value))
.ToList();
foreach (var child in emptyAttributes)
{
var prop = GetPropertyInfoForAnElement(properties, child.Name.LocalName);
if (prop == null)
{
continue;
}
if (prop.IsDefined(typeof(RequiredAttribute), false))
{
throw new WitsmlException(ErrorCodes.MissingRequiredData);
}
}
}
}
/// <summary>
/// Updates a data object in the data store.
/// </summary>
/// <param name="parser">The input template parser.</param>
/// <param name="dataObject">The data object to be updated.</param>
public override void Update(WitsmlQueryParser parser, Log dataObject)
{
// Update ChannelSets + data via the ChannelSet data adapter
foreach (var childParser in parser.ForkProperties("ChannelSet", ObjectTypes.ChannelSet))
{
var channelSet = WitsmlParser.Parse <ChannelSet>(childParser.Root);
ChannelSetDataAdapter.Update(childParser, channelSet);
}
var uri = GetUri(dataObject);
UpdateEntity(parser, uri);
}
public async Task Trajectory200_PutGrowingPart_Can_Add_TrajectoryStation()
{
AddParents();
await RequestSessionAndAssert();
var handler = _client.Handler <IStoreCustomer>();
var uri = Trajectory.GetUri();
var dataObject = CreateDataObject(uri, Trajectory);
// Put a Trajectory with no stations in the store.
await PutAndAssert(handler, dataObject);
// Create a TrajectoryStation and Encode it
var uid = "TrajStation-1";
var trajectoryStation = CreateTrajectoryStation(uid, LengthUom.ft, "TestDatum", 1);
var data = Encoding.UTF8.GetBytes(WitsmlParser.ToXml(trajectoryStation));
var contentType = EtpContentTypes.Witsml200.For(ObjectTypes.TrajectoryStation);
// Call PutGrowingPart to add the TrajectoryStation to the Trajectory
var dataAdapter = DevKit.Container.Resolve <IGrowingObjectDataAdapter>(ObjectNames.Trajectory200);
dataAdapter.PutGrowingPart(_client.Adapter, uri, contentType, data);
// Get the Trajectory Object from the store
var args = await GetAndAssert(handler, uri);
// Check Data Object XML
Assert.IsNotNull(args?.Message.DataObject);
var xml = args.Message.DataObject.GetString();
var result = Parse <Trajectory>(xml);
// Validate that the Trajectory could be retrieved from the store and the MDMin matches the station that was entered.
Assert.IsNotNull(result);
Assert.IsNotNull(result.MDMin);
Assert.AreEqual(1, result.MDMin.Value);
var dataObjectGet = dataAdapter.GetGrowingPart(_client.Adapter, uri, uid);
var trajectoryStationObject = GetTrajectoryStation(dataObjectGet);
Assert.IsNotNull(trajectoryStationObject);
Assert.IsNotNull(trajectoryStationObject.MD);
Assert.IsNotNull(trajectoryStationObject.Incl);
Assert.IsNotNull(trajectoryStationObject.Azi);
Assert.AreEqual(trajectoryStation.MD.Value, trajectoryStationObject.MD.Value);
Assert.AreEqual(trajectoryStation.Incl.Value, trajectoryStationObject.Incl.Value);
Assert.AreEqual(trajectoryStation.Azi.Value, trajectoryStationObject.Azi.Value);
}
private static EtpUri? GetUriFromXml(XElement element, string version, string objectType)
{
var type = ObjectTypes.GetObjectGroupType(objectType, version) ??
ObjectTypes.GetObjectType(objectType, version);
var entity = WitsmlParser.Parse(type, element?.Document?.Root, false);
var collection = entity as IEnergisticsCollection;
var uri = collection?.Items
.OfType<IDataObject>()
.Select(x => x.GetUri())
.FirstOrDefault() ?? (entity as AbstractObject)?.GetUri();
return uri;
}
/// <summary>
/// Handles the PutObject message of the Store protocol.
/// </summary>
/// <param name="header">The message header.</param>
/// <param name="putObject">The put object message.</param>
protected override void HandlePutObject(IMessageHeader header, PutObject putObject)
{
base.HandlePutObject(header, putObject);
var uri = this.CreateAndValidateUri(putObject.DataObject.Resource.Uri, header.MessageId);
if (!uri.IsValid)
{
return;
}
if (!this.ValidateUriParentHierarchy(uri, header.MessageId))
{
return;
}
if (!this.ValidateUriObjectType(uri, header.MessageId))
{
return;
}
try
{
var data = putObject.DataObject.GetString();
if (EtpContentType.Json.EqualsIgnoreCase(uri.ContentType.Format))
{
var objectType = uri.IsRelatedTo(EtpUris.Witsml200) || uri.IsRelatedTo(EtpUris.Eml210)
? ObjectTypes.GetObjectType(uri.ObjectType, uri.Family, OptionsIn.DataVersion.Version200.Value)
: ObjectTypes.GetObjectGroupType(uri.ObjectType, uri.Family, uri.Version);
var instance = Energistics.Etp.Common.EtpExtensions.Deserialize(objectType, data);
data = WitsmlParser.ToXml(instance);
}
WitsmlOperationContext.Current.Request = new RequestContext(Functions.PutObject, uri.ObjectType, data, null, null);
var dataAdapter = Container.Resolve <IEtpDataProvider>(new ObjectName(uri.ObjectType, uri.GetDataSchemaVersion()));
dataAdapter.Put(putObject.DataObject);
Acknowledge(header.MessageId);
}
catch (ContainerException ex)
{
this.UnsupportedObject(ex, putObject.DataObject.Resource.Uri, header.MessageId);
}
catch (WitsmlException ex)
{
ProtocolException((int)EtpErrorCodes.InvalidObject, $"Invalid object: {ex.Message}; Error code: {(int)ex.ErrorCode}", header.MessageId);
}
}
public WMLS_DeleteFromStoreResponse Delete <TList, TObject>(TObject entity, string wmlTypeIn = null, string capClient = null, string optionsIn = null, bool partialDelete = false) where TList : IEnergisticsCollection
{
string typeIn, xmlIn;
SetupParameters <TList, TObject>(List(entity), wmlTypeIn, out typeIn, out xmlIn);
if (!partialDelete)
{
var element = WitsmlParser.Parse(xmlIn);
WitsmlParser.RemoveEmptyElements(element.Root);
xmlIn = element.ToString();
}
return(DeleteFromStore(typeIn, xmlIn, capClient, optionsIn));
}
/// <summary>
/// Invoked during execution of the query, with the
/// pre populated expression tree.
/// </summary>
/// <param name="expression">Target expression block</param>
/// <returns>Expected result</returns>
public IEnumerable <T> Execute(Ast.Expression expression)
{
Visit(expression);
var optionsIn = string.Join(";", Options.Select(x => $"{x.Key}={x.Value}"));
var objectType = ObjectTypes.GetObjectType <T>();
var xmlIn = WitsmlParser.ToXml(Query, true);
Context.LogQuery(Functions.GetFromStore, objectType, xmlIn, optionsIn);
using (var client = Context.Connection.CreateClientProxy())
{
var wmls = (IWitsmlClient)client;
string suppMsgOut, xmlOut = string.Empty;
var result = Enumerable.Empty <T>();
short returnCode;
try
{
returnCode = wmls.WMLS_GetFromStore(objectType, xmlIn, optionsIn, null, out xmlOut, out suppMsgOut);
}
catch (Exception ex)
{
Logger.ErrorFormat("Error querying store: {0}", ex);
returnCode = -1;
suppMsgOut = "Error querying store:" + ex.GetBaseException().Message;
}
try
{
if (returnCode > 0)
{
var document = WitsmlParser.Parse(xmlOut);
var response = WitsmlParser.Parse <TList>(document.Root);
result = (IEnumerable <T>)response.Items;
}
}
catch (WitsmlException ex)
{
Logger.ErrorFormat("Error parsing query response: {0}{2}{2}{1}", xmlOut, ex, Environment.NewLine);
returnCode = (short)ex.ErrorCode;
suppMsgOut = ex.Message + " " + ex.GetBaseException().Message;
}
Context.LogResponse(Functions.GetFromStore, objectType, xmlIn, optionsIn, xmlOut, returnCode, suppMsgOut);
return(result);
}
}
/// <summary>
/// Formats the specified XML.
/// </summary>
/// <param name="xml">The XML.</param>
/// <returns>The formatted XML.</returns>
public static string Format(string xml)
{
if (string.IsNullOrWhiteSpace(xml))
{
return(string.Empty);
}
try
{
return(WitsmlParser.Parse(xml, false).ToString());
}
catch
{
return(string.Empty);
}
}
/// <summary>
/// Returns the server capabilities object as XML.
/// </summary>
/// <returns>A capServers object as an XML string.</returns>
public string ToXml()
{
if (!string.IsNullOrWhiteSpace(_capServerXml))
{
return(_capServerXml);
}
var capServer = GetCapServer();
if (capServer != null)
{
_capServerXml = WitsmlParser.ToXml(capServer);
}
return(_capServerXml);
}
/// <summary>
/// Partially delete the log data.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="parser">The parser.</param>
/// <param name="channels">The current logCurve information.</param>
/// <param name="currentRanges">The current channel index ranges.</param>
protected override void PartialDeleteLogData(EtpUri uri, WitsmlQueryParser parser, List <LogCurveInfo> channels, Dictionary <string, Range <double?> > currentRanges)
{
var uidToMnemonics = channels.ToDictionary(c => c.Uid, c => c.Mnemonic.Value);
var updatedRanges = new Dictionary <string, Range <double?> >();
WitsmlParser.RemoveEmptyElements(parser.Root);
var delete = WitsmlParser.Parse <LogList>(parser.Root, false).Log.FirstOrDefault();
var current = GetEntity(uri);
delete.IndexType = current.IndexType;
delete.Direction = current.Direction;
var indexRange = currentRanges[current.IndexCurve];
if (!indexRange.Start.HasValue || !ToDeleteLogData(delete, parser))
{
return;
}
TimeSpan?offset = null;
var indexCurve = current.IndexCurve;
var indexChannel = current.LogCurveInfo.FirstOrDefault(l => l.Mnemonic.Value == indexCurve);
if (DeleteAllLogData(current, delete, updatedRanges))
{
ChannelDataChunkAdapter.Delete(uri);
foreach (var curve in current.LogCurveInfo)
{
updatedRanges.Add(curve.Mnemonic.Value, new Range <double?>(null, null));
}
}
else
{
var deletedChannels = GetDeletedChannels(current, uidToMnemonics);
var defaultDeleteRange = GetDefaultDeleteRange(current, delete);
var isTimeLog = current.IsTimeLog();
var updateRanges = GetDeleteQueryIndexRange(delete, channels, uidToMnemonics, indexCurve, current.IsIncreasing(), isTimeLog);
offset = currentRanges[indexCurve].Offset;
var ranges = MergePartialDeleteRanges(deletedChannels, defaultDeleteRange, currentRanges, updateRanges, indexCurve, current.IsIncreasing());
ChannelDataChunkAdapter.PartialDeleteLogData(uri, indexCurve, current.IsIncreasing(), isTimeLog, deletedChannels, ranges, updatedRanges);
}
UpdateIndexRange(uri, current, updatedRanges, updatedRanges.Keys.ToList(), current.IsTimeLog(), indexChannel?.Unit, offset, false, true);
}
/// <summary>
/// Adds a data object to the data store.
/// </summary>
/// <param name="parser">The input template parser.</param>
/// <param name="dataObject">The data object to be added.</param>
public override void Add(WitsmlQueryParser parser, Log dataObject)
{
// Add ChannelSets + data via the ChannelSet data adapter
foreach (var childParser in parser.ForkProperties("ChannelSet", ObjectTypes.ChannelSet))
{
var channelSet = WitsmlParser.Parse <ChannelSet>(childParser.Root);
ChannelSetDataAdapter.Add(childParser, channelSet);
}
// Clear ChannelSet data properties
foreach (var channelSet in dataObject.ChannelSet)
{
channelSet.Data = null;
}
InsertEntity(dataObject);
}
private IEnergisticsCollection ExecuteGetFromStoreQuery(string objectType, string xmlIn, string optionsIn, bool logQuery = true, bool logResponse = true)
{
if (logQuery)
{
LogQuery(Functions.GetFromStore, objectType, xmlIn, optionsIn);
}
IEnergisticsCollection result = null;
string suppMsgOut, xmlOut;
var returnCode = ExecuteQuery(Functions.GetFromStore, objectType, xmlIn, optionsIn, out xmlOut, out suppMsgOut);
if (returnCode < 1)
{
if (logResponse)
{
LogResponse(Functions.GetFromStore, objectType, xmlIn, optionsIn, null, returnCode, suppMsgOut);
}
return(null);
}
try
{
if (returnCode > 0)
{
var listType = ObjectTypes.GetObjectGroupType(objectType, DataSchemaVersion);
var document = WitsmlParser.Parse(xmlOut);
result = WitsmlParser.Parse(listType, document.Root) as IEnergisticsCollection;
}
}
catch (WitsmlException ex)
{
_log.ErrorFormat("Error parsing query response: {0}{2}{2}{1}", xmlOut, ex, Environment.NewLine);
returnCode = (short)ex.ErrorCode;
suppMsgOut = ex.Message + " " + ex.GetBaseException().Message;
}
if (logResponse)
{
LogResponse(Functions.GetFromStore, objectType, xmlIn, optionsIn, xmlOut, returnCode, suppMsgOut);
}
return(result);
}
/// <summary>
/// Validates the required WITSML input template.
/// </summary>
/// <param name="xml">The XML input template.</param>
/// <exception cref="WitsmlException"></exception>
public static XDocument ValidateInputTemplate(string xml)
{
_log.Debug("Validating WITSML input template.");
if (string.IsNullOrWhiteSpace(xml))
{
throw new WitsmlException(ErrorCodes.MissingInputTemplate);
}
XDocument doc = WitsmlParser.Parse(xml);
if (string.IsNullOrEmpty(GetNamespace(doc)))
{
throw new WitsmlException(ErrorCodes.MissingDefaultWitsmlNamespace);
}
return(doc);
}
private IEnergisticsCollection ExecuteQuery(string objectType, string xmlIn, string optionsIn)
{
LogQuery(Functions.GetFromStore, objectType, xmlIn, optionsIn);
using (var client = Connection.CreateClientProxy())
{
var wmls = (IWitsmlClient)client;
string suppMsgOut, xmlOut = string.Empty;
IEnergisticsCollection result = null;
short returnCode;
try
{
returnCode = wmls.WMLS_GetFromStore(objectType, xmlIn, optionsIn, null, out xmlOut, out suppMsgOut);
}
catch (Exception ex)
{
_log.ErrorFormat("Error querying store: {0}", ex);
returnCode = -1;
suppMsgOut = "Error querying store:" + ex.GetBaseException().Message;
}
try
{
if (returnCode > 0)
{
var listType = ObjectTypes.GetObjectGroupType(objectType, DataSchemaVersion);
var document = WitsmlParser.Parse(xmlOut);
result = WitsmlParser.Parse(listType, document.Root) as IEnergisticsCollection;
}
}
catch (WitsmlException ex)
{
_log.ErrorFormat("Error parsing query response: {0}{2}{2}{1}", xmlOut, ex, Environment.NewLine);
returnCode = (short)ex.ErrorCode;
suppMsgOut = ex.Message + " " + ex.GetBaseException().Message;
}
LogResponse(Functions.GetFromStore, objectType, xmlIn, optionsIn, xmlOut, returnCode, suppMsgOut);
return(result);
}
}
/// <summary>
/// Updates a data object in the data store.
/// </summary>
/// <param name="parser">The input template parser.</param>
/// <param name="dataObject">The data object to be updated.</param>
public override void Update(WitsmlQueryParser parser, Log dataObject)
{
using (var transaction = GetTransaction())
{
transaction.SetContext(dataObject.GetUri());
// Update ChannelSets + data via the ChannelSet data adapter
foreach (var childParser in parser.ForkProperties("ChannelSet", ObjectTypes.ChannelSet))
{
var channelSet = WitsmlParser.Parse <ChannelSet>(childParser.Root);
ChannelSetDataAdapter.Update(childParser, channelSet);
}
var uri = GetUri(dataObject);
UpdateEntity(parser, uri);
// Commit transaction
transaction.Commit();
}
}
/// <summary>
/// Sets the properties of the <see cref="IDataObject"/> instance.
/// </summary>
/// <typeparam name="T">The type of entity.</typeparam>
/// <param name="dataObject">The data object.</param>
/// <param name="entity">The entity.</param>
/// <param name="uri">The URI.</param>
/// <param name="name">The name.</param>
/// <param name="childCount">The child count.</param>
/// <param name="lastChanged">The last changed in microseconds.</param>
public static void SetDataObject <T>(IDataObject dataObject, T entity, EtpUri uri, string name, int childCount = -1, long lastChanged = 0)
{
if (entity == null)
{
dataObject.SetString(null);
}
else if (entity is string)
{
dataObject.SetString(entity.ToString());
}
else
{
var data = EtpContentType.Json.EqualsIgnoreCase(uri.ContentType.Format)
? Energistics.Etp.Common.EtpExtensions.Serialize(entity)
: WitsmlParser.ToXml(entity, removeTypePrefix: true);
dataObject.SetString(data, false);
}
double version;
var uuid = double.TryParse(uri.Version, out version) && version >= 2.0 ? uri.ObjectId : null;
if (string.IsNullOrWhiteSpace(uuid))
{
uuid = entity.GetPropertyValue <string>(ObjectTypes.Uuid);
}
dataObject.Resource = new Resource
{
Uri = uri,
Uuid = uuid ?? string.Empty,
Name = name,
ChildCount = childCount,
ContentType = uri.ContentType,
ResourceType = ResourceTypes.DataObject.ToString(),
CustomData = new Dictionary <string, string>(),
LastChanged = lastChanged,
ChannelSubscribable = uri.IsChannelSubscribable(),
ObjectNotifiable = uri.IsObjectNotifiable()
};
}
/// <summary>
/// Converts a data object collection to XML and optionally converts to a requested version.
/// </summary>
/// <param name="request">The GetFromStore request.</param>
/// <param name="collection">The data object collection.</param>
/// <returns></returns>
private string GetXmlOut(WMLS_GetFromStoreRequest request, IEnergisticsCollection collection)
{
if (collection == null)
{
return(string.Empty);
}
EnsureCapServerProviders();
var optionsIn = WitsmlOperationContext.Current.OptionsIn;
string requestedVersion;
// Attempt transformation if client requested a different version
if (optionsIn.TryGetValue(OptionsIn.DataVersion.Keyword, out requestedVersion) &&
_capServerMap.ContainsKey(requestedVersion) &&
collection.GetVersion() != requestedVersion)
{
_log.Debug($"Transforming XMLOut to data schema version {requestedVersion}");
collection = WitsmlParser.Transform(collection, requestedVersion);
}
return(WitsmlParser.ToXml(collection));
}
/// <summary>
/// Parses the nested element to the specified type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="element">The element.</param>
/// <returns>The parsed object.</returns>
/// <exception cref="WitsmlException"></exception>
protected object ParseNestedElement(Type type, XElement element)
{
if (element.DescendantsAndSelf().Any(e => (!e.HasAttributes && string.IsNullOrWhiteSpace(e.Value)) || e.Attributes().Any(a => string.IsNullOrWhiteSpace(a.Value))))
{
throw new WitsmlException(ErrorCodes.EmptyNewElementsOrAttributes);
}
var clone = element.UpdateRootElementName(type);
try
{
return(WitsmlParser.Parse(type, clone));
}
catch
{
// Try again without the default namespace specified
clone = new XElement(clone)
{
Name = clone.Name.LocalName
};
return(WitsmlParser.Parse(type, clone));
}
}
/// <summary>
/// Puts the growing part for a growing object.
/// </summary>
/// <param name="etpAdapter">The ETP adapter.</param>
/// <param name="uri">The growing obejct's URI.</param>
/// <param name="contentType">Type of the content.</param>
/// <param name="data">The data.</param>
public override void PutGrowingPart(IEtpAdapter etpAdapter, EtpUri uri, string contentType, byte[] data)
{
var dataObject = etpAdapter.CreateDataObject();
dataObject.Data = data;
// Convert byte array to TrajectoryStation
var trajectoryStationXml = dataObject.GetString();
var tsDocument = WitsmlParser.Parse(trajectoryStationXml);
var trajectoryStation = WitsmlParser.Parse <TrajectoryStation>(tsDocument.Root);
// Merge TrajectoryStation into the Trajectory if it is not null
if (trajectoryStation != null)
{
// Get the Trajectory for the uri
var entity = GetEntity(uri);
entity.TrajectoryStation = trajectoryStation.AsList();
var document = WitsmlParser.Parse(WitsmlParser.ToXml(entity));
var parser = new WitsmlQueryParser(document.Root, ObjectTypes.GetObjectType <Trajectory>(), null);
UpdateTrajectoryWithStations(parser, entity, uri, true);
}
}
protected virtual DataObject GetDataObject(string objectType, string version, object dataObject, bool includeObjectData)
{
var jObject = dataObject as JObject;
if (jObject != null || dataObject is string)
{
var type = ObjectTypes.GetObjectGroupType(objectType, version) ??
ObjectTypes.GetObjectType(objectType, version);
dataObject = jObject?.ToObject(type) ??
WitsmlParser.Parse(type, WitsmlParser.Parse(dataObject.ToString()).Root);
}
var collection = dataObject as IEnergisticsCollection;
var iDataObject = collection?.Items?.OfType <IDataObject>().FirstOrDefault();
var cDataObject = iDataObject as ICommonDataObject;
var aDataObject = dataObject as Witsml200.AbstractObject;
var uri = iDataObject?.GetUri() ?? aDataObject?.GetUri() ?? new EtpUri();
var name = iDataObject?.Name ?? aDataObject?.Citation?.Title;
var lastChanged = cDataObject?.CommonData?.DateTimeLastChange?.ToUnixTimeMicroseconds() ??
aDataObject?.Citation?.LastUpdate?.ToUnixTimeMicroseconds();
var etpDataObject = new DataObject();
// Do not return DataObject.Data if not requested in original subscription
StoreStoreProvider.SetDataObject(
etpDataObject,
includeObjectData ? dataObject : null,
uri,
name,
-1,
lastChanged.GetValueOrDefault());
return(etpDataObject);
}
/// <summary>
/// Gets the channel data records for the specified URI and range.
/// </summary>
/// <param name="uri">The uri of the data object</param>
/// <param name="range">The range of the channel data</param>
/// <param name="mnemonics">The channel mnemonics</param>
/// <param name="requestLatestValues">true if only the latest values are requested, false otherwise</param>
/// <param name="optimizeStart"></param>
/// <returns></returns>
public List <List <List <object> > > GetChannelData(EtpUri uri, Range <double?> range, List <string> mnemonics, int?requestLatestValues, bool optimizeStart = false)
{
var entity = GetEntity(uri);
var stations = GetStations(entity, range.Start, range.End);
if (requestLatestValues.HasValue)
{
stations = stations.AsEnumerable().Reverse() // Pick from the bottom
.Take(requestLatestValues.Value).Reverse() // Revert to original sort
.ToList();
}
return(stations
.Select(x => new List <List <object> >
{
new List <object> {
x.MD.Value
},
new List <object> {
WitsmlParser.ToXml(x)
}
})
.ToList());
}
private void UpdateInput(bool fromXml = true)
{
var input = Data.Document.Text;
if (string.IsNullOrWhiteSpace(input))
{
return;
}
XDocument doc;
try
{
doc = WitsmlParser.Parse(input);
ResetDataEditorBorderColor();
}
catch (Exception ex)
{
_log.Warn("Error parsing data object XML", ex);
DataEditorBorderColor = "#FFFF0000";
return;
}
var root = doc.Root;
if (root == null)
{
return;
}
var version = root.Attribute("version");
bool match;
if (version != null)
{
var ns = root.GetDefaultNamespace();
if (string.IsNullOrWhiteSpace(version.Value))
{
return;
}
var dataObject = root.Elements().FirstOrDefault();
var nameElement = dataObject?.Element(ns + "name");
if (nameElement == null)
{
nameElement = new XElement(ns + "name");
dataObject?.AddFirst(nameElement);
}
match = CheckInputDataXmlMatch(dataObject, version.Value, "uid", nameElement);
if (!match)
{
UpdateInput(dataObject, version.Value, "uid", nameElement, fromXml);
}
}
else
{
var schemaVersion = OptionsIn.DataVersion.Version200;
if (string.IsNullOrWhiteSpace(schemaVersion?.Value))
{
return;
}
var citationRoot = root
.Elements()
.FirstOrDefault(e => e.Name.LocalName == "Citation");
var nameElement = citationRoot
?.Elements()
.FirstOrDefault(e => e.Name.LocalName == "Title");
var ns = citationRoot?.GetDefaultNamespace();
if (ns != null && nameElement == null)
{
nameElement = new XElement(ns + "Title");
citationRoot.AddFirst(nameElement);
}
match = CheckInputDataXmlMatch(root, schemaVersion.Value, "uuid", nameElement);
if (!match)
{
UpdateInput(root, schemaVersion.Value, "uuid", nameElement, fromXml);
}
}
if (!fromXml && !match)
{
Data.SetText(doc.ToString());
}
}
private string ToXml(object instance)
{
return(WitsmlParser.ToXml(instance));
}
public WitsmlQueryParser Parser <T>(T entity, string options = null)
{
var document = WitsmlParser.Parse(EnergisticsConverter.ObjectToXml(entity));
return(new WitsmlQueryParser(document.Root, ObjectTypes.GetObjectType <T>(), options));
}
/// <summary>
/// Partially delete the log data.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="parser">The parser.</param>
/// <param name="channels">The current logCurve information.</param>
/// <param name="currentRanges">The current channel index ranges.</param>
protected override void PartialDeleteLogData(EtpUri uri, WitsmlQueryParser parser, List <LogCurveInfo> channels, Dictionary <string, Range <double?> > currentRanges)
{
var uidToMnemonics = channels.ToDictionary(c => c.Uid, c => c.Mnemonic.Value);
var updatedRanges = new Dictionary <string, Range <double?> >();
WitsmlParser.RemoveEmptyElements(parser.Root);
var delete = WitsmlParser.Parse <LogList>(parser.Root, false).Log.FirstOrDefault();
var current = GetEntity(uri);
delete.IndexType = current.IndexType;
delete.Direction = current.Direction;
var indexRange = currentRanges[current.IndexCurve];
var headerOnlyDeletion = !indexRange.Start.HasValue || !ToDeleteLogData(delete, parser);
// Audit if only the header is being updated
if (headerOnlyDeletion)
{
AuditPartialDeleteHeaderOnly(delete, parser);
UpdateGrowingObject(current, null);
return;
}
TimeSpan?offset = null;
var indexCurve = current.IndexCurve;
var indexChannel = current.LogCurveInfo.FirstOrDefault(l => l.Mnemonic.Value == indexCurve);
if (DeleteAllLogData(current, delete, updatedRanges))
{
ChannelDataChunkAdapter.Delete(uri);
foreach (var curve in current.LogCurveInfo)
{
updatedRanges.Add(curve.Mnemonic.Value, new Range <double?>(null, null));
}
AuditPartialDelete(current, GetMnemonics(uri), indexRange.Start, indexRange.End);
}
else
{
var deletedChannels = GetDeletedChannels(current, uidToMnemonics);
var defaultDeleteRange = GetDefaultDeleteRange(current, delete);
var isTimeLog = current.IsTimeLog();
var updateRanges = GetDeleteQueryIndexRange(delete, channels, uidToMnemonics, indexCurve, current.IsIncreasing(), isTimeLog);
offset = currentRanges[indexCurve].Offset;
var ranges = MergePartialDeleteRanges(deletedChannels, defaultDeleteRange, currentRanges, updateRanges, indexCurve, current.IsIncreasing());
ChannelDataChunkAdapter.PartialDeleteLogData(uri, indexCurve, current.IsIncreasing(), isTimeLog, deletedChannels, ranges, updatedRanges);
var affectedMnemonics = updatedRanges.Keys.Where(x => x != indexCurve).ToArray();
if (defaultDeleteRange.IsClosed())
{
AuditPartialDelete(current, affectedMnemonics, defaultDeleteRange.Start, defaultDeleteRange.End);
}
else
{
// If full channels were deleted
if (deletedChannels.Count > 0)
{
var minRange =
channels.Where(x => deletedChannels.ContainsIgnoreCase(x.Mnemonic.Value))
.Min(x => x.GetIndexRange(current.IsIncreasing(), isTimeLog).Start);
var maxRange =
channels.Where(x => deletedChannels.ContainsIgnoreCase(x.Mnemonic.Value))
.Max(x => x.GetIndexRange(current.IsIncreasing(), isTimeLog).End);
AuditPartialDelete(current, deletedChannels.ToArray(), minRange, maxRange, true);
}
else
{
AuditPartialDelete(current, affectedMnemonics, updateRanges.Min(x => x.Value.Start), updateRanges.Max(x => x.Value.End));
}
}
}
var logHeaderUpdate = GetIndexRangeUpdate(uri, current, updatedRanges, updatedRanges.Keys.ToList(), current.IsTimeLog(), indexChannel?.Unit, offset, true);
UpdateGrowingObject(current, logHeaderUpdate);
}
/// <summary>
/// Creates a reader from an xml string
/// </summary>
/// <param name="data"></param>
public TrajectoryDataReader(string data) : this(WitsmlParser.Parse(data))
{
}
/// <summary>
/// Parses the specified XML string.
/// </summary>
/// <param name="element">The XML element.</param>
/// <returns>The data object instance.</returns>
protected override TObject Parse(XElement element)
{
var list = WitsmlParser.Parse <TList>(element, false);
return(list.Items.Cast <TObject>().FirstOrDefault());
}
