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