private void TestUri(CmUri testURI, ContentNamespace ns, int publicationId, int itemId, int itemTypeId)
{
Assert.AreEqual(ns, testURI.Namespace, "Namespace should match");
Assert.AreEqual(publicationId, testURI.PublicationId, "Publication ID should match");
Assert.AreEqual(itemId, testURI.ItemId, "Item ID should match");
Assert.AreEqual(itemTypeId, (int)testURI.ItemType, "Item Type ID should match");
}
public static IGraphQLRequest BinaryComponent(CmUri cmUri, string customMetaFilter,
IContextData contextData, IContextData globalContextData) =>
new QueryBuilder().WithQueryResource("BinaryComponentByCmUri", true).WithCmUri(cmUri)
.WithCustomMetaFilter(customMetaFilter)
.WithContextData(contextData)
.WithContextData(globalContextData)
.Build();
public override Localization GetLocalization(string localizationId)
{
using (new Tracer(localizationId))
{
Localization result;
if (!KnownLocalizations.TryGetValue(localizationId, out result))
{
// Check for namespace prefix (ish: or tcm:)
if (localizationId.StartsWith("ish:"))
{
CmUri uri = CmUri.FromString(localizationId);
result = new DocsLocalization(uri.PublicationId);
}
else if (localizationId.StartsWith("tcm:"))
{
CmUri uri = CmUri.FromString(localizationId);
result = new Localization {
Id = uri.ItemId.ToString()
};
}
else
{
// Attempt to resolve it from Docs
var client = ApiClientFactory.Instance.CreateClient();
Publication publication = client.GetPublication(ContentNamespace.Docs, int.Parse(localizationId), null, null);
result = publication != null ? new DocsLocalization(publication.PublicationId) : base.GetLocalization(localizationId);
}
KnownLocalizations[localizationId] = result;
}
return(result);
}
}
public async Task <Page> GetPageAsync(CmUri cmUri,
string customMetaFilter, ContentIncludeMode contentIncludeMode, IContextData contextData,
CancellationToken cancellationToken = default(CancellationToken))
=> (await _client.ExecuteAsync <ContentQuery>(
GraphQLRequests.Page(cmUri, customMetaFilter, contentIncludeMode, contextData, GlobalContextDataInternal),
cancellationToken).ConfigureAwait(false))
.TypedResponseData.Page;
public static IGraphQLRequest Page(CmUri cmUri, string customMetaFilter, ContentIncludeMode contentIncludeMode,
IContextData contextData, IContextData globalContextData) =>
new QueryBuilder().WithQueryResource("PageByCmUri", true).WithCmUri(cmUri)
.WithCustomMetaFilter(customMetaFilter)
.WithContentIncludeMode(contentIncludeMode)
.WithContextData(contextData)
.WithContextData(globalContextData)
.Build();
protected override TaxonomyNode CreateTaxonomyNode(Keyword keyword, int expandLevels, NavigationFilter filter, ILocalization localization)
{
TaxonomyNode node = base.CreateTaxonomyNode(keyword, expandLevels, filter, localization);
string ishRefUri = (string)keyword.KeywordMeta.GetFirstValue("ish.ref.uri");
if (ishRefUri != null)
{
var ish = CmUri.FromString(ishRefUri);
node.Url = $"/{ish.PublicationId}/{ish.ItemId}";
}
node.Visible = true;
return(node);
}
public void TestCreateFromStringWithVersion()
{
string uriString = CreateCmUriString(ContentNamespace.Sites, _testPublicationId, _testItemId, _testItemTypeId, _testVersion);
try
{
CmUri testURI = new CmUri(uriString);
TestUri(testURI, ContentNamespace.Sites, _testPublicationId, _testItemId, _testItemTypeId, _testVersion);
}
catch (Exception ex)
{
Assert.Fail($"Failed to parse {uriString} : {ex}");
}
}
private static UgcComments CreateUgcCommentsEntity(Localization localization, string modelId, ItemType itemType)
{
var mvcData = new Common.Models.MvcData("Ugc:Ugc:UgcComments");
mvcData.ControllerAreaName = "Ugc";
return(new UgcComments
{
Target =
CmUri.FromString(
$"{localization.CmUriScheme}:{localization.Id}-{modelId}-{(int)itemType}"),
MvcData = mvcData,
IsVolatile = true
});
}
public void TestInvalidNamespace()
{
string uri = "tcr:1-2-3-4";
try
{
CmUri testURI = new CmUri(uri);
Assert.Fail($"Should not be able to create a uri from {uri}");
}
catch (Exception)
{
//expected behaviour
}
}
public void TestCreateFromStringWithVersionButNoItemType()
{
string uriString =
$"{UriPrefix}{_testPublicationId}{UriSeparator}{_testItemId}{UriSeparator}v{_testVersion}";
try
{
CmUri testURI = new CmUri(uriString);
TestUri(testURI, ContentNamespace.Sites, _testPublicationId, _testItemId, (int)ItemType.Component, _testVersion);
}
catch (Exception ex)
{
Assert.Fail($"Failed to parse {uriString} : {ex}");
}
}
public void TestTcmUriOperatorOverloads()
{
CmUri testURI1 = new CmUri(ContentNamespace.Sites, 1, 2, ItemType.Category, 4);
CmUri testURI2 = new CmUri(ContentNamespace.Sites, 1, 2, ItemType.Category, 4);
Assert.AreEqual(testURI1.ToString(), testURI2.ToString(), "CmUri ToString() should be equal");
Assert.AreEqual(testURI1.GetHashCode(), testURI2.GetHashCode(), "CmUri hashCode() should be equal");
Assert.IsTrue(testURI1 == testURI2, "CmUri objects should be equal");
Assert.IsTrue(testURI1.Equals(testURI2), "CmUri objects should be equal");
HashSet <CmUri> testSet = new HashSet <CmUri> {
testURI1
};
Assert.IsTrue(testSet.Contains(testURI1), "Due to object equality, set contains should match");
}
/// <summary>
/// Resolves a link URI (TCM URI or site URL) to a normalized site URL.
/// </summary>
/// <param name="sourceUri">The source URI (TCM URI or site URL)</param>
/// <param name="resolveToBinary">Specifies whether a link to a Multimedia Component should be resolved directly to its Binary (<c>true</c>) or as a regular Component link.</param>
/// <param name="localization">The context Localization (optional, since the TCM URI already contains a Publication ID, but this allows resolving in a different context).</param>
/// <returns>The resolved URL.</returns>
public string ResolveLink(string sourceUri, bool resolveToBinary = false, ILocalization localization = null)
{
if (sourceUri == null)
{
return(null);
}
string url = SiteConfiguration.CacheProvider.GetOrAdd($"{sourceUri}:{resolveToBinary}:{localization?.Id}",
CacheRegions.LinkResolving,
() =>
{
if (sourceUri.IsCmUri())
{
var client = ApiClientFactory.Instance.CreateClient();
var cmUri = new CmUri(sourceUri);
switch (cmUri.ItemType)
{
case ItemType.Component:
return(resolveToBinary ?
client.ResolveBinaryLink(cmUri.Namespace, cmUri.PublicationId, cmUri.ItemId, null) :
client.ResolveComponentLink(cmUri.Namespace, cmUri.PublicationId, cmUri.ItemId, null, null));
case ItemType.Page:
return(client.ResolvePageLink(cmUri.Namespace, cmUri.PublicationId, cmUri.ItemId));
}
}
else
{
return(sourceUri);
}
return(null);
});
// Strip off default extension / page name
if (url == null || !url.EndsWith(Constants.DefaultExtension))
{
return(url);
}
url = url.Substring(0, url.Length - Constants.DefaultExtension.Length);
if (url.EndsWith("/" + Constants.DefaultExtensionLessPageName))
{
url = url.Substring(0, url.Length - Constants.DefaultExtensionLessPageName.Length);
}
return(url);
}
private static UgcPostCommentForm CreateUgcPostCommentEntity(Localization localization, string modelId, ItemType itemType, ContentModelData postFormConfig)
{
var mvcData = new Common.Models.MvcData("Ugc:Ugc:UgcPostCommentForm");
mvcData.ControllerAreaName = "Ugc";
return(new UgcPostCommentForm
{
Target =
CmUri.FromString(
$"{localization.CmUriScheme}:{localization.Id}-{modelId}-{(int)itemType}"),
MvcData = mvcData,
UserNameLabel = GetValue <string>(postFormConfig, "userNameLabel"),
EmailAddressLabel = GetValue <string>(postFormConfig, "emailAddressLabel"),
ContentLabel = GetValue <string>(postFormConfig, "contentLabel"),
SubmitButtonLabel = GetValue <string>(postFormConfig, "submitButtonLabel"),
NoContentMessage = GetValue <string>(postFormConfig, "noContentMessage"),
NoEmailAddressMessage = GetValue <string>(postFormConfig, "noEmailAddressMessage"),
NoUserNameMessage = GetValue <string>(postFormConfig, "noUserNameMessage"),
IsVolatile = true
});
}
private static CmUri CreateUri(int publicationId, int pageId)
{
ILocalization localization = WebRequestContext.Localization;
return(CmUri.Create(localization.CmUriScheme, publicationId, pageId, ItemType.Page));
}
public Page GetPage(CmUri cmUri, string customMetaFilter, ContentIncludeMode contentIncludeMode,
IContextData contextData)
=> _client.Execute <ContentQuery>(
GraphQLRequests.Page(cmUri, customMetaFilter, contentIncludeMode, contextData, GlobalContextDataInternal))
.TypedResponseData.Page;
public BinaryComponent GetBinaryComponent(CmUri cmUri, string customMetaFilter, IContextData contextData)
=>
_client.Execute <ContentQuery>(GraphQLRequests.BinaryComponent(cmUri, customMetaFilter, contextData,
GlobalContextDataInternal))
.TypedResponseData.BinaryComponent;
public async Task <BinaryComponent> GetBinaryComponentAsync(CmUri cmUri, string customMetaFilter,
IContextData contextData, CancellationToken cancellationToken = default(CancellationToken)) => (await
_client.ExecuteAsync <ContentQuery>(
GraphQLRequests.BinaryComponent(cmUri, customMetaFilter, contextData, GlobalContextDataInternal),
cancellationToken).ConfigureAwait(false))
.TypedResponseData.BinaryComponent;
public QueryBuilder WithCmUri(CmUri cmUri)
=> WithVariable("cmUri", cmUri).WithNamespace(cmUri.Namespace).WithPublicationId(cmUri.PublicationId);
public static ContentNamespace Namespace(this ILocalization localization) => CmUri.NamespaceIdentiferToId(localization.CmUriScheme);
private string CreateCmUriString(ContentNamespace ns, int publicationId, int itemId)
=> $"{CmUri.NamespaceIdToIdentifer(ns)}:{publicationId}{UriSeparator}{itemId}";