/// <summary> /// Creates an ETP URI segment from the specified object string. /// </summary> /// <param name="object">The object string.</param> /// <param name="defaultFamily">The default family if the object does not specify it.</param> /// <param name="defaultVersion">The default family version if the object string does not specify it.</param> /// <returns></returns> private static Segment CreateSegment(string @object, string defaultFamily, string defaultVersion) { var match = Definition.EtpObjectOrFolderRegex.Match(@object); var objectType = GetFirstMatch(match, Definition.ObjectTypeGroup); var objectId = GetFirstMatch(match, Definition.ObjectIdGroup); if (objectId != null) { objectId = WebUtility.UrlDecode(objectId); } var objectVersion = GetFirstMatch(match, Definition.ObjectVersionGroup); CorrectCommonObjectFamilyAndVersion(objectType, ref defaultFamily, ref defaultVersion); var family = GetFirstMatch(match, Definition.FamilyGroup) ?? defaultFamily; family = EtpDataObjectType.TryGetFamily(family); var shortVersion = GetFirstMatch(match, Definition.ShortVersionGroup); var version = EtpDataObjectType.TryGetFamilyVersionFromShortVersion(family, shortVersion) ?? defaultVersion; objectType = EtpContentType.FormatObjectType(objectType, version); return(new Segment(family, version, objectType, objectId, objectVersion?.Replace("''", "'"))); }
public void EtpDataType_Rejects_DataObjectType_Without_Version() { var expected = "witsml"; var dataType = new EtpDataObjectType(expected); Assert.IsFalse(dataType.IsValid); }
public void EtpDataType_Can_Parse_Witsml_1411_Well_DataObjectType() { var expected = "witsml14.well"; var dataType = new EtpDataObjectType(expected); Assert.IsTrue(dataType.IsValid); Assert.AreEqual("well", dataType.ObjectType); Assert.AreEqual("1.4.1.1", dataType.Version); }
public void EtpDataType_Can_Parse_Witsml_20_TrajectoryStation_DataObjectType() { var expected = "witsml20.part_TrajectoryStation"; var dataType = new EtpDataObjectType(expected); Assert.IsTrue(dataType.IsValid); Assert.AreEqual("TrajectoryStation", dataType.ObjectType); Assert.AreEqual("2.0", dataType.Version); }
public void EtpDataType_Can_Parse_Witsml_20_Well_DataObjectType() { var expected = "witsml20.Well"; var dataType = new EtpDataObjectType(expected); Assert.IsTrue(dataType.IsValid); Assert.AreEqual("Well", dataType.ObjectType); Assert.AreEqual("2.0", dataType.Version); }
public void EtpDataType_For_Can_Create_1411_Well_DataObjectType() { var expected = "witsml14."; var dataType = new EtpDataObjectType(expected).For("well"); Assert.IsTrue(dataType.IsValid); Assert.AreEqual("well", dataType.ObjectType); Assert.AreEqual("1.4.1.1", dataType.Version); Assert.AreEqual(expected + "well", (string)dataType); }
public void EtpDataType_Can_Parse_Base_DataObjectType_With_Trailing_Semicolon() { var expected = "witsml20."; var dataType = new EtpDataObjectType(expected); Assert.IsTrue(dataType.IsValid); Assert.IsTrue(dataType.IsBaseType); Assert.AreEqual("witsml", dataType.Family); Assert.AreEqual("2.0", dataType.Version); }
/// <summary> /// Appends the specified object type and optional object identifier to the <see cref="EtpUri" />. /// </summary> /// <param name="family">The object family.</param> /// <param name="version">The object version.</param> /// <param name="objectType">The object type.</param> /// <param name="objectId">The object identifier.</param> /// <param name="objectVersion">The object version.</param> /// <param name="encode">if set to <c>true</c> encode the object identifier value.</param> /// <returns>A new <see cref="EtpUri" /> instance.</returns> public EtpUri Append(string family, string version, string objectType, string objectId = null, string objectVersion = null, bool encode = false) { objectType = EtpContentType.FormatObjectType(objectType, version); CorrectCommonObjectFamilyAndVersion(objectType, ref family, ref version); if (encode && objectId != null) { objectId = WebUtility.UrlEncode(objectId); } var uri = UriWithoutSuffix ?? string.Empty; string slash = null; if (uri.Length == 0 || uri[uri.Length - 1] != '/') { slash = "/"; } if (IsEtp11) { if (objectId != null) { objectId = $"({objectId})"; } return(new EtpUri($"{uri}{slash}{objectType}{objectId}{Query}{Hash}")); } else { family = family ?? Family; version = version ?? Version; var shortVersion = EtpDataObjectType.TryGetFamilyShortVersionFromVersion(family, version); string objectIdAndVersion = null; if (objectId != null && objectVersion != null) { objectIdAndVersion = $"(uuid={objectId},version='{objectVersion.Replace("'","''")}')"; } else if (objectId != null) { objectIdAndVersion = $"({objectId})"; } return(new EtpUri($"{uri}{slash}{family}{shortVersion}.{objectType}{objectIdAndVersion}{Query}{Hash}")); } }
public void EtpDataType_Can_Be_Converted_To_ContentType() { var dataType = new EtpDataObjectType("witsml14.well"); Assert.IsTrue(dataType.IsValid); Assert.AreEqual("well", dataType.ObjectType); Assert.AreEqual("1.4.1.1", dataType.Version); var converted = "application/x-witsml+xml;version=1.4.1.1;type=well"; var contentType = dataType.ToContentType(); Assert.IsTrue(contentType.IsValid); Assert.AreEqual("well", contentType.ObjectType); Assert.AreEqual("1.4.1.1", contentType.Version); Assert.AreEqual(Formats.Xml, contentType.Format); Assert.AreEqual(converted, contentType.ToString()); }
/// <summary> /// Creates a Base URI for the specified ETP version with the specified family, version and dataspace. /// </summary> /// <param name="etpVersion">The ETP version.</param> /// <param name="family">The family.</param> /// <param name="version">The version.</param> /// <param name="dataspace">The dataspace.</param> /// <returns>The ETP URI Base.</returns> private static string CreateBaseUri(EtpVersion etpVersion, string family, string version, string dataspace) { var sb = new StringBuilder(); var appendSlash = false; if (etpVersion == EtpVersion.v11) { sb.Append($"{RootUri11.Uri}"); } else { sb.Append($"{RootUri12.Uri}"); } if (!string.IsNullOrEmpty(dataspace)) { if (etpVersion == EtpVersion.v11) { sb.Append(dataspace); } else { sb.Append($"dataspace({dataspace})"); } appendSlash = true; } if (etpVersion == EtpVersion.v11 && !string.IsNullOrEmpty(family) && !string.IsNullOrEmpty(version)) { if (appendSlash) { sb.Append("/"); } var shortVersion = EtpDataObjectType.TryGetFamilyShortVersionFromVersion(family, version); sb.Append($"{family}{shortVersion}"); } return(sb.ToString()); }
/// <summary> /// Converts the URI to an ETP 1.2 URI. /// </summary> /// <returns>The converted URI.</returns> public EtpUri AsEtp12() { if (IsEtp12 || !IsValid) { return(this); } var Base = CreateBaseUri(EtpVersion.v12, NamespaceFamily, NamespaceVersion, Dataspace); var sb = new StringBuilder(Base); var appendSlash = Base[Base.Length - 1] != '/'; foreach (var segment in GetSegments()) { if (appendSlash) { sb.Append("/"); } var shortVersion = EtpDataObjectType.TryGetFamilyShortVersionFromVersion(segment.Family, segment.Version); sb.Append($"{segment.Family}{shortVersion}.{segment.ObjectType}"); if (!string.IsNullOrEmpty(segment.ObjectId)) { if (!string.IsNullOrEmpty(segment.ObjectVersion)) { sb.Append($"(uuid={segment.ObjectId},version='{segment.ObjectVersion.Replace("'","''")}')"); } else { sb.Append($"({segment.ObjectId})"); } } appendSlash = true; } sb.Append(Query); sb.Append(Hash); return(new EtpUri(sb.ToString())); }
/// <summary> /// Initializes a new instance of the <see cref="EtpUri"/> struct. /// </summary> /// <param name="uri">The URI string.</param> public EtpUri(string uri) { var uriMatch = Definition.EtpUriRegex.Match(uri); _parent = null; Uri = uri; IsValid = uriMatch.Success; if (!IsValid) { return; } if (WasGroupMatched(uriMatch, Definition.Etp11UriGroup)) { EtpVersion = EtpVersion.v11; } else { EtpVersion = EtpVersion.v12; } Query = GetFirstMatch(uriMatch, Definition.QueryGroup) ?? string.Empty; Hash = GetFirstMatch(uriMatch, Definition.HashGroup) ?? string.Empty; Dataspace = GetFirstMatch(uriMatch, Definition.DataspaceGroup) ?? string.Empty; var family = GetFirstMatch(uriMatch, Definition.FamilyGroup); NamespaceFamily = EtpDataObjectType.TryGetFamily(family); var shortVersion = GetFirstMatch(uriMatch, Definition.ShortVersionGroup); NamespaceVersion = EtpDataObjectType.TryGetFamilyVersionFromShortVersion(family, shortVersion); _objectSegments = GetAllMatches(uriMatch, Definition.ObjectOrFolderGroup); if (_objectSegments != null) { var segment = CreateSegment(_objectSegments[_objectSegments.Length - 1], NamespaceFamily, NamespaceVersion); Family = segment.Family; Version = segment.Version; ObjectType = segment.ObjectType; ObjectId = segment.ObjectId; ObjectVersion = segment.ObjectVersion; } else { Family = NamespaceFamily; Version = NamespaceVersion; } DataObjectType = new EtpDataObjectType(Family, Version, ObjectType); Format = GetQueryStringFormat(Query, Formats.Xml); ContentType = new EtpContentType(Family, Version, ObjectType, Format); IsRootUri = WasGroupMatched(uriMatch, Definition.RootUriGroup); IsFamilyVersionUri = WasGroupMatched(uriMatch, Definition.FamilyVersionUriGroup); IsDataspaceUri = IsRootUri /* Default Dataspace */ || WasGroupMatched(uriMatch, Definition.DataspaceUriGroup); IsDataRootUri = (IsEtp11 && IsFamilyVersionUri) || (IsEtp12 && IsDataspaceUri); IsBaseUri = IsRootUri || IsDataspaceUri || IsFamilyVersionUri; IsQueryUri = WasGroupMatched(uriMatch, Definition.QueryUriGroup); IsObjectUri = WasGroupMatched(uriMatch, Definition.ObjectUriGroup); IsFolderUri = WasGroupMatched(uriMatch, Definition.FolderUriGroup); IsHierarchicalUri = WasGroupMatched(uriMatch, Definition.HierarchicalUriGroup) || WasGroupMatched(uriMatch, Definition.TemplateUriGroup); HasEmptyObjectId = WasGroupMatched(uriMatch, Definition.EmptyIdGroup); var canonical = WasGroupMatched(uriMatch, Definition.CanonicalUriGroup) || (IsObjectUri && NamespaceVersion.StartsWith("1")); // Special case for 1.x URIs. if (WasGroupMatched(uriMatch, Definition.DataspaceGroup) && string.IsNullOrEmpty(Dataspace)) // Disallow eml:///dataspace() { canonical = false; } if (HasEmptyObjectId || WasGroupMatched(uriMatch, Definition.EmptyVersionGroup)) // Disallow empty object IDs or empty object versions { canonical = false; } IsCanonicalUri = canonical; IsAlternateUri = !IsCanonicalUri; // Allow for special cases. IsHierarchicalUri = WasGroupMatched(uriMatch, Definition.HierarchicalUriGroup); IsFolderTemplateUri = WasGroupMatched(uriMatch, Definition.FolderUriGroup) || WasGroupMatched(uriMatch, Definition.FolderTemplateUriGroup); IsObjectTemplateUri = WasGroupMatched(uriMatch, Definition.ObjectTemplateUriGroup); IsTemplateUri = IsFolderTemplateUri || IsObjectTemplateUri; if (IsBaseUri) { UriBase = UriWithoutSuffix; } else { UriBase = GetFirstMatch(uriMatch, Definition.BaseGroup) + "/"; } }