public Article(SessionAwareCoreServiceClient client, TcmUri location)
: base(client)
{
ComponentData component = (ComponentData)Client.GetDefaultData(ItemType.Component, location, ReadOptions);
component.Schema = new LinkToSchemaData { IdRef = ContentManager.ResolveUrl(Constants.ArticleSchemaUrl) };
Content = component;
}
public void Transform(Engine engine, Package package)
{
TemplatingLogger log = TemplatingLogger.GetLogger(GetType());
if (package.GetByName(Package.OutputName) == null)
{
log.Error("Could not find \"Output\" item in Package. This template building block should be the last TBB in your template.");
return;
}
Item output = package.GetByName(Package.OutputName);
string outputText = output.GetAsString();
bool outputchanged = false;
foreach (Match m in TcmUriRegEx.Matches(outputText))
{
log.Debug("Found " + m.Value);
TcmUri uri = new TcmUri(m.Value);
if(uri.GetVersionlessUri().ToString().Equals(m.Value)) continue;
log.Debug("Found version information on uri " + m.Value + ". Removing.");
outputText = outputText.Replace(m.Value, uri.GetVersionlessUri().ToString());
outputchanged = true;
}
if (outputchanged)
{
output.SetAsString(outputText);
package.Remove(output);
package.PushItem(Package.OutputName, output);
}
}
protected void Page_Load(object sender, EventArgs e)
{
// get the current logged in user
string user = HttpContext.Current.User.Identity.Name;
if (!String.IsNullOrEmpty(user))
{
// set LogonUser
TridionTreeView.LogonUser = user;
}
// process querystring parameters
string start = Request.QueryString["start"];
string types = Request.QueryString["types"];
string pubid = Request.QueryString["pubid"];
if (!String.IsNullOrEmpty(start))
{
// override StartFromUri
TridionTreeView.StartFromUri = start;
}
else if (!String.IsNullOrEmpty(pubid))
{
// override StartFromUri with current publication id
TcmUri uri = new TcmUri(pubid);
TridionTreeView.StartFromUri = uri.ToString();
}
if (!String.IsNullOrEmpty(types))
{
// override SelectTypes
TridionTreeView.SelectTypes = Convert.ToInt32(types);
}
}
public string ResolveLink(string componentUri)
{
TcmUri uri = new TcmUri(componentUri);
if (!uri.Equals(emptyTcmUri))
{
Cache cache = HttpContext.Current.Cache;
string cacheKey = String.Format(CACHEKEY_FORMAT, componentUri);
if (cache[cacheKey] != null)
{
return (String)cache[cacheKey];
}
else
{
Link link = componentLink.GetLink(uri.ToString());
if (!link.IsResolved)
{
return null;
}
cache.Insert(cacheKey, link.Url, null, DateTime.Now.AddSeconds(30), TimeSpan.Zero); //TODO should this be configurable?
return link.Url;
}
}
return null;
}
/// <summary>
/// Constrctor
/// </summary>
/// <param name="engine"></param>
/// <param name="componentID"></param>
/// <param name="templateID"></param>
/// <param name="index"></param>
public ComponentPresentationModel(Engine engine, TcmUri componentID, TcmUri templateID, int index)
{
_engine = engine;
_componentID = componentID;
_templateID = templateID;
Index = index;
}
/// <summary>
/// Retrieves the Compound Template invocation XML for a given page or component template Uri
/// </summary>
/// <param name="compoundTemplateWebService"><see cref="T:Tridion.ContentManager.Templating.CompoundTemplates.DomainModel.Proxy.CompoundTemplateWebService" /></param>
/// <param name="templateUri">Tridion template URI.</param>
/// <returns>Compound Template invocation XML as <see cref="T:String.String" /></returns>
/// <exception cref="System.NotSupportedException">Unsupported template type</exception>
public static String GetAssemblyKey(this CompoundTemplateWebService compoundTemplateWebService, String templateUri)
{
if (compoundTemplateWebService != null)
{
XmlElement templateXml = compoundTemplateWebService.ReadItem(templateUri, EnumOpenMode.OpenModeView, 1919);
String templateType = templateXml.SelectSingleNode("/tcm:Data/tcm:Type", namespaceManager).InnerText;
if (!String.Equals(templateType, "CompoundTemplate", StringComparison.OrdinalIgnoreCase))
throw new NotSupportedException("Unsupported template type: " + templateType);
String owningPublication = templateXml.SelectSingleNode("/tcm:Info/tcm:BluePrintInfo/tcm:OwningPublication/@xlink:href", namespaceManager).InnerText;
String version = templateXml.SelectSingleNode("/tcm:Info/tcm:VersionInfo/tcm:Version", namespaceManager).InnerText;
String revision = templateXml.SelectSingleNode("/tcm:Info/tcm:VersionInfo/tcm:Revision", namespaceManager).InnerText;
String content = templateXml.SelectSingleNode("/tcm:Data/tcm:Content/tcm:PublisherScript", namespaceManager).InnerText;
content = content.Replace("\n", "\r\n");
TcmUri tcmPublication = new TcmUri(owningPublication);
TcmUri tcmTemplate = new TcmUri(templateUri);
TcmUri tcmParent = new TcmUri(tcmTemplate.ItemId, tcmTemplate.ItemType, tcmPublication.ItemId);
int hashCode = 0;
if (!String.IsNullOrEmpty(content))
hashCode = content.GetHashCode();
return String.Format("{0}/{1}.{2}/{3:X}", tcmParent, version, revision, hashCode);
}
return String.Empty;
}
protected ContentItem(TcmUri itemId, SessionAwareCoreServiceClient client)
{
ReadOptions = new ReadOptions();
Client = client;
Content = (ComponentData) client.Read(itemId, ReadOptions);
ContentManager = new ContentManager(Client);
}
/// <summary>
/// Add a new <see cref="T:Tridion.ContentManager.TcmUri"/> value to the current <see cref="T:Tridion.ContentManager.Templating.Package" />
/// </summary>
/// <param name="package"><see cref="T:Tridion.ContentManager.Templating.Package" /></param>
/// <param name="name">Name.</param>
/// <param name="value">Value.</param>
public static void AddComponent(this Package package, String name, TcmUri value)
{
if (package != null)
{
Item packageItem = package.CreateTridionItem(ContentType.Component, value != null ? value : TcmUri.UriNull);
package.PushItem(name, packageItem);
}
}
protected ComponentLink GetComponentLink(TcmUri uri)
{
if (!_componentLinks.ContainsKey(uri.PublicationId))
{
_componentLinks.Add(uri.PublicationId, new ComponentLink(uri.PublicationId));
}
return _componentLinks[uri.PublicationId];
}
public static TcmUri GetLocalUri(TcmUri uriPublication, TcmUri uriItem)
{
TcmUri uriReturn = new TcmUri(uriItem.ItemId, uriItem.ItemType, uriPublication.ItemId);
TemplatingLogger log = TemplatingLogger.GetLogger(typeof(TemplateUtilities));
log.Info("(getLocalUri)Old URI was:" + uriItem.ToString());
log.Info("(getLocalUri)New URI is:" + uriReturn.ToString());
return uriReturn;
}
public string GetContent(string uri, string templateUri = "")
{
var tcmUri = new TcmUri(uri);
string urlParameters = string.IsNullOrEmpty(templateUri) ?
string.Format("{0}/GetContent/{1}/{2}", controller, tcmUri.PublicationId, tcmUri.ItemId) :
string.Format("{0}/GetContent/{1}/{2}/{3}", controller, tcmUri.PublicationId, tcmUri.ItemId, new TcmUri(templateUri).ItemId);
return Execute<string>(urlParameters);
}
public ComponentPresentationModel(Engine engine, Component component, ComponentTemplate template, int index)
{
_engine = engine;
_component = new ComponentModel(engine, component);
_template = new ComponentTemplateModel(engine, template);
_componentID = component.Id;
_templateID = template.Id;
Index = index;
}
public string ResolveLink(string sourcePageUri, string componentUri, string excludeComponentTemplateUri)
{
var compUri = new TcmUri(componentUri);
var pageUri = new TcmUri(sourcePageUri);
var templateUri = new TcmUri(excludeComponentTemplateUri);
string urlParameters = string.Format("{0}/ResolveLink/{1}/{2}/{3}/{4}", controller, PublicationId, pageUri.ItemId, compUri.ItemId, templateUri.ItemId);
return Execute<string>(urlParameters);
}
public string GetContent(string uri, string templateUri = "")
{
LoggerService.Debug(">>GetContent({0})", LoggingCategory.Performance, uri);
TcmUri tcmUri = new TcmUri(uri);
TcmUri templateTcmUri = new TcmUri(templateUri);
T.ComponentPresentationFactory cpFactory = GetComponentPresentationFactory(tcmUri.PublicationId);
T.ComponentPresentation cp = null;
if (!String.IsNullOrEmpty(templateUri))
{
cp = cpFactory.GetComponentPresentation(tcmUri.ItemId, templateTcmUri.ItemId);
if (cp != null)
return cp.Content;
}
if (!string.IsNullOrEmpty(selectByComponentTemplateId))
{
cp = cpFactory.GetComponentPresentation(tcmUri.ItemId, Convert.ToInt32(selectByComponentTemplateId));
if (cp != null)
{
LoggerService.Debug("<<GetContent({0}) - by ct id", LoggingCategory.Performance, uri);
return cp.Content;
}
}
if (!string.IsNullOrEmpty(selectByOutputFormat))
{
cp = cpFactory.GetComponentPresentationWithOutputFormat(tcmUri.ItemId, selectByOutputFormat);
if (cp != null)
{
LoggerService.Debug("<<GetContent({0}) - by output format", LoggingCategory.Performance, uri);
return cp.Content;
}
}
LoggerService.Debug("GetContent: about to get component presentations with Highst Priority for {0}", LoggingCategory.Performance, tcmUri.ToString());
cp = cpFactory.GetComponentPresentationWithHighestPriority(tcmUri.ItemId);
LoggerService.Debug("GetContent: get component presentations with Highst Priority for {0}", LoggingCategory.Performance, tcmUri.ToString());
if (cp != null)
return cp.Content;
//foreach (Tridion.ContentDelivery.DynamicContent.ComponentPresentation _cp in cps)
//{
// if (_cp != null)
// {
// LoggerService.Debug("<<GetContent({0}) - find all", LoggingCategory.Performance, uri);
// return _cp.Content;
// }
//}
LoggerService.Debug("<<GetContent({0}) - not found", LoggingCategory.Performance, uri);
return string.Empty;
}
public string ResolveLink(string componentUri)
{
TcmUri uri = new TcmUri(componentUri);
if (!uri.Equals(emptyTcmUri))
{
Link link = componentLink.GetLink(uri.ToString());
return link.IsResolved ? link.Url : null;
}
return null;
}
public bool IsSiteEditEnabled(ITridionItemData item)
{
int publicationId = 0;
try
{
publicationId = new TcmUri(item.TcmUri).PublicationId;
}
catch (Exception)
{
publicationId = 0;
}
return IsSiteEditEnabled(publicationId);
}
protected ComponentLink GetComponentLink(TcmUri uri)
{
if (_componentLinks.ContainsKey(uri.PublicationId))
return _componentLinks[uri.PublicationId];
lock (lock1)
{
if (!_componentLinks.ContainsKey(uri.PublicationId)) // we must test again, because in the mean time another thread might have added a record to the dictionary!
{
_componentLinks.Add(uri.PublicationId, new ComponentLink(uri.PublicationId));
}
}
return _componentLinks[uri.PublicationId];
}
/// <summary>
/// Get all urls of published pages
/// </summary>
/// <param name="includeExtensions"></param>
/// <param name="pathStarts"></param>
/// <param name="publicationID"></param>
/// <returns></returns>
public string[] GetAllPublishedPageUrls(string[] includeExtensions, string[] pathStarts)
{
Query pageQuery = new Query();
ItemTypeCriteria isPage = new ItemTypeCriteria(64); // TODO There must be an enum of these somewhere
PublicationCriteria currentPublication = new PublicationCriteria(PublicationId); //Todo: add logic to determine site on url
Criteria pageInPublication = CriteriaFactory.And(isPage, currentPublication);
if (includeExtensions.Length > 0)
{
PageURLCriteria[] extensionsCriteria = new PageURLCriteria[includeExtensions.Length];
int criteriaCount = 0;
foreach (string pageExtension in includeExtensions)
{
extensionsCriteria.SetValue(new PageURLCriteria("%" + pageExtension, Criteria.Like), criteriaCount);
criteriaCount++;
}
Criteria allExtensions = CriteriaFactory.Or(extensionsCriteria);
pageInPublication = CriteriaFactory.And(pageInPublication, allExtensions);
}
if (pathStarts.Length > 0)
{
PageURLCriteria[] pathCriteria = new PageURLCriteria[pathStarts.Length];
int criteriaCount = 0;
foreach (string requiredPath in pathStarts)
{
pathCriteria.SetValue(new PageURLCriteria(requiredPath + "%", Criteria.Like), criteriaCount);
criteriaCount++;
}
Criteria allPaths = CriteriaFactory.Or(pathCriteria);
pageInPublication = CriteriaFactory.And(pageInPublication, allPaths);
}
Query findPages = new Query(pageInPublication);
string[] pageUris = findPages.ExecuteQuery();
// Need to get PageMeta data to find all the urls
List<string> pageUrls = new List<string>();
foreach (string uri in pageUris)
{
TcmUri tcmUri = new TcmUri(uri);
PageMetaFactory metaFactory = GetPageMetaFactory(tcmUri.PublicationId);
IPageMeta currentMeta = metaFactory.GetMeta(uri);
pageUrls.Add(currentMeta.UrlPath);
}
return pageUrls.ToArray();
}
/// <summary>
/// Returns the Component contents which could be found. Components that couldn't be found don't appear in the list.
/// </summary>
/// <param name="componentUris"></param>
/// <returns></returns>
public List<string> GetContentMultiple(string[] componentUris)
{
TcmUri uri = new TcmUri(componentUris.First());
ComponentPresentationFactory cpFactory = new ComponentPresentationFactory(uri.PublicationId);
var components =
componentUris
.Select(componentUri => (Tridion.ContentDelivery.DynamicContent.ComponentPresentation)cpFactory.FindAllComponentPresentations(componentUri)[0])
.Where(cp => cp != null)
.Select(cp => cp.Content)
.ToList();
return components;
}
public IDictionary<string, IComponentMeta> FindComponentMetas(string[] schemaUris, DateTime sinceLastPublished)
{
int pubId = new TcmUri(schemaUris.First()).PublicationId;
string[] componentMetas;
using (var client = new TridionBrokerServiceClient())
{
componentMetas = client.FindLatestComponentMetasBySchemas(schemaUris, sinceLastPublished);
}
return
componentMetas
.Select(metaXml => XElement.Parse(metaXml))
.ToDictionary(k => String.Format("tcm:{0}-{1}", pubId, k.Element("Id").Value), v => CreateComponentMeta(v));
}
private void CreateBinaryLink(XmlDocument xmlContent, XmlNode node, TcmUri item, Component c)
{
_package.PushItem(_package.CreateMultimediaItem(item));
Binary binary = _engine.PublishingContext.RenderedItem.AddBinary(c, "");
node.Attributes.RemoveAll();
String publishedPath = GetUrlForBinary(binary.Url);
XmlAttribute attr = xmlContent.CreateAttribute("href");
attr.Value = publishedPath;
node.Attributes.SetNamedItem(attr);
attr = xmlContent.CreateAttribute("title");
attr.Value = c.Title;
node.Attributes.SetNamedItem(attr);
}
/// <summary>
/// Get 'current' PublishTransaction. It tries to identify a PublishTransaction from the publish queue that is on the
/// given TcmUri, Publication, User, etc.
/// </summary>
/// <param name="engine">Engine object</param>
/// <param name="tcmUri">String representing the tcmuri of the item to check</param>
/// <returns>PublishTransaction if found; or null, otherwise</returns>
public static PublishTransaction GetPublishTransaction(Engine engine, String tcmUri)
{
String binaryPath = engine.PublishingContext.PublishInstruction.RenderInstruction.BinaryStoragePath;
Regex tcmRegex = new Regex(@"tcm_\d+-\d+-66560");
Match match = tcmRegex.Match(binaryPath);
if (match.Success)
{
String transactionId = match.Value.Replace('_', ':');
TcmUri transactionUri = new TcmUri(transactionId);
return new PublishTransaction(transactionUri, engine.GetSession());
}
return FindPublishTransaction(engine, tcmUri);
}
public ListItem(XmlElement element)
{
XElement el = element.ConvertToXElement();
_id = new TcmUri(el.AttributeValueOrEmpty("ID"));
_parentId = new TcmUri(el.AttributeValueOrEmpty("ParentOrgItemID"));
_title = el.AttributeValueOrEmpty("Title");
_path = el.AttributeValueOrEmpty("Path");
_modified = DateTime.Parse(el.AttributeValueOrEmpty("Modified"));
_isShared = Boolean.Parse(el.AttributeValueOrEmpty("IsShared"));
_isLocalized = Boolean.Parse(el.AttributeValueOrEmpty("IsLocalized"));
_trusteeId = new TcmUri(el.AttributeValueOrEmpty("TrusteeID"));
_icon = el.AttributeValueOrEmpty("Icon");
_url = el.AttributeValueOrEmpty("URL");
}
public string ResolvePageLink(string tcmUri)
{
TcmUri pageUri = new TcmUri(tcmUri);
using (var pageLink = new PageLink(pageUri.PublicationId))
{
var link = pageLink.GetLink(pageUri.ItemId);
if (link != null)
{
return link.Url;
}
else
{
return String.Empty;
}
}
}
public virtual string ResolveLink(string sourcePageUri, string componentUri, string excludeComponentTemplateUri)
{
TcmUri componentUriToLinkTo = new TcmUri(componentUri);
TcmUri pageUri = new TcmUri(sourcePageUri);
TcmUri componentTemplateUri = new TcmUri(excludeComponentTemplateUri);
if (!componentUriToLinkTo.Equals(emptyTcmUri))
{
Link link = GetComponentLink(componentUriToLinkTo).GetLink(pageUri.ToString(), componentUriToLinkTo.ToString(), componentTemplateUri.ToString(), String.Empty, String.Empty, false, LinkToAnchor);
if (!link.IsResolved)
{
return null;
}
return LinkToAnchor && link.Anchor != "0" ? string.Format("{0}#{1}", link.Url, TridionHelper.GetLocalAnchorTag(pageUri, componentUriToLinkTo, componentTemplateUri, link.Anchor)) : link.Url;
}
return null;
}
public string ResolveLink(string sourcePageUri, string componentUri, string excludeComponentTemplateUri)
{
TcmUri componentUriToLinkTo = new TcmUri(componentUri);
TcmUri pageUri = new TcmUri(sourcePageUri);
TcmUri componentTemplateUri = new TcmUri(excludeComponentTemplateUri);
if (!componentUriToLinkTo.Equals(emptyTcmUri))
{
Link link = componentLink.GetLink(pageUri.ToString(), componentUriToLinkTo.ToString(), componentTemplateUri.ToString(), String.Empty, String.Empty, false, false);
if (!link.IsResolved)
{
return null;
}
return link.Url;
}
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="TransformXml"/> class.
/// </summary>
/// <param name="engine"><see cref="T:Tridion.ContentManager.Templating.Engine" /></param>
/// <param name="package"><see cref="T:Tridion.ContentManager.Templating.Package" /></param>
/// <param name="templateBase"><see cref="T:TcmTemplating.TemplateBase" /></param>
/// <param name="templateBuildingBlock">Tridion template building block to use as source</param>
public TransformXml(Engine engine, Package package, TemplateBase templateBase, TcmUri templateBuildingBlockUri)
: this(engine, package, templateBase)
{
if (templateBuildingBlockUri.ItemType != ItemType.TemplateBuildingBlock)
throw new ArgumentException("templateBuildingBlock is not ItemType.TemplateBuildingBlock");
TemplateBuildingBlock templateBuildingBlock = engine.GetObject(templateBuildingBlockUri) as TemplateBuildingBlock;
String content = templateBuildingBlock.Content.Replace("tcm:include", "xsl:include");
using (StringReader sr = new StringReader(content))
{
using (XmlReader reader = XmlReader.Create(sr))
{
mXslCompiledTransform.Load(reader, XsltSettings, new XmlTcmUriResolver(engine));
}
}
}
public ListItem(XmlElement element)
{
if (element.HasAttribute("ID"))
{
_id = new TcmUri(element.GetAttribute("ID"));
}
if (element.HasAttribute("ParentOrgItemID"))
{
_parentId = new TcmUri(element.GetAttribute("ParentOrgItemID"));
}
if (element.HasAttribute("Title"))
{
_title = element.GetAttribute("Title");
}
if (element.HasAttribute("Path"))
{
_path = element.GetAttribute("Path");
}
if (element.HasAttribute("Modified"))
{
_modified = DateTime.Parse(element.GetAttribute("Modified"));
}
if (element.HasAttribute("IsShared"))
{
_isShared = Boolean.Parse(element.GetAttribute("IsShared"));
}
if (element.HasAttribute("IsLocalized"))
{
_isLocalized = Boolean.Parse(element.GetAttribute("IsLocalized"));
}
if (element.HasAttribute("TrusteeID"))
{
_trusteeId = new TcmUri(element.GetAttribute("TrusteeID"));
}
if (element.HasAttribute("Icon"))
{
_icon = element.GetAttribute("Icon");
}
if (element.HasAttribute("URL"))
{
_url = element.GetAttribute("URL");
}
}
public string GetContent(string uri, string templateUri = "")
{
TcmUri tcmUri = new TcmUri(uri);
TcmUri templateTcmUri = new TcmUri(templateUri);
Tridion.ContentDelivery.DynamicContent.ComponentPresentationFactory cpFactory = new ComponentPresentationFactory(PublicationId);
Tridion.ContentDelivery.DynamicContent.ComponentPresentation cp = null;
if (!String.IsNullOrEmpty(templateUri))
{
cp = cpFactory.GetComponentPresentation(tcmUri.ItemId, templateTcmUri.ItemId);
if (cp != null)
return cp.Content;
}
if (!string.IsNullOrEmpty(selectByComponentTemplateId))
{
cp = cpFactory.GetComponentPresentation(tcmUri.ItemId, Convert.ToInt32(selectByComponentTemplateId));
if (cp != null)
return cp.Content;
}
if (!string.IsNullOrEmpty(selectByOutputFormat))
{
cp = cpFactory.GetComponentPresentationWithOutputFormat(tcmUri.ItemId, selectByOutputFormat);
if (cp != null)
return cp.Content;
}
IList cps = cpFactory.FindAllComponentPresentations(tcmUri.ItemId);
foreach (Tridion.ContentDelivery.DynamicContent.ComponentPresentation _cp in cps)
{
if (_cp != null)
{
if (_cp.Content.Contains("<Component"))
{
return _cp.Content;
}
}
}
return string.Empty;
}
private ILinkProvider GetLinkProvider(string uri)
{
TcmUri u = new TcmUri(uri);
if (u == null)
// invalid uri, return null
return null;
if (_linkProviders.ContainsKey(u.PublicationId))
return _linkProviders[u.PublicationId];
lock (lock1)
{
if (!_linkProviders.ContainsKey(u.PublicationId)) // we must test again, because in the mean time another thread might have added a record to the dictionary!
{
Type t = LinkProvider.GetType();
ILinkProvider lp = (ILinkProvider)Activator.CreateInstance(t);
lp.PublicationId = u.PublicationId;
_linkProviders.Add(u.PublicationId, lp);
}
}
return _linkProviders[u.PublicationId];
}
/// <summary>
/// Gets the <see cref="T:Tridion.ContentManager.ContentManagement.IdentifiableObject"/> object specified by the ID
/// </summary>
/// <param name="ID">IdentifiableObject ID</param>
/// <returns><see cref="T:Tridion.ContentManager.ContentManagement.IdentifiableObject"/></returns>
public T GetObject <T>(TcmUri ID) where T : IdentifiableObject
{
return(mEngine.GetObject(ID) as T);
}
/// <summary>
/// On (Save, and) Check-in of a Component, create a Page for that Component and update an index Page with the Component and publish both to a staging target.
/// </summary>
/// <remarks>
/// The metadata of the Folder the Component resides in, will be used as the configuration for the actions.
/// </remarks>
/// <param name="subject">checked in Component</param>
/// <param name="args">check in event arguments</param>
/// <param name="phase">event phase</param>
private static void ComponentCheckInAction(Component subject, CheckInEventArgs args, EventPhases phase)
{
// get Folder from Component for configuration metadata
Folder folder = (Folder)subject.OrganizationalItem;
// proceed when Folder has metadata
if (folder.Metadata == null)
{
return;
}
ItemFields metadata = new ItemFields(folder.Metadata, folder.MetadataSchema);
ReiConfig config = new ReiConfig(metadata);
// proceed when metadata contains valid URIs, and Schema of Component is recognised
if (!config.IsValid || subject.Schema.Id.ItemId != config.SchemaUri.ItemId)
{
return;
}
// create list of items to publish
List <IdentifiableObject> items = new List <IdentifiableObject>();
// if Component is already used on any Page then no need to create new Page and update index, just publish Component
UsingItemsFilter pageFilter = new UsingItemsFilter(subject.Session)
{
ItemTypes = new List <ItemType> {
ItemType.Page
}
};
if (subject.HasUsingItems(pageFilter))
{
items.Add(subject);
}
else
{
// create Page and add Component Presentation (using Context Publication of Structure Group)
TcmUri localUri = ReiConfig.TransformTcmUri(subject.Id, config.StructureGroupUri);
Component localComponent = new Component(localUri, subject.Session);
ComponentTemplate componentTemplate = new ComponentTemplate(config.ComponentTemplateUri, subject.Session);
Page page = new Page(subject.Session, config.StructureGroupUri);
try
{
page.Title = subject.Title;
page.FileName = GetSafeFileName(subject.Title);
page.PageTemplate = new PageTemplate(config.PageTemplateUri, subject.Session);
page.ComponentPresentations.Add(new ComponentPresentation(localComponent, componentTemplate));
page.Save(true);
// add Page to publish items list
items.Add(page);
}
catch (Exception ex)
{
Logger.Write(ex, ReiConfig.Name, LoggingCategory.General, TraceEventType.Error);
}
// add Component to index Page (using Context Publication of index Page)
localUri = ReiConfig.TransformTcmUri(subject.Id, config.IndexPageUri);
localComponent = new Component(localUri, subject.Session);
componentTemplate = new ComponentTemplate(config.IndexComponentTemplateUri, subject.Session);
Page indexPage = new Page(config.IndexPageUri, subject.Session);
try
{
indexPage.CheckOut();
indexPage.ComponentPresentations.Add(new ComponentPresentation(localComponent, componentTemplate));
indexPage.Save(true);
// add index Page to publish items list
items.Add(indexPage);
}
catch (Exception ex)
{
Logger.Write(ex, ReiConfig.Name, LoggingCategory.General, TraceEventType.Error);
}
}
// publish items
if (items.Count > 0)
{
List <TargetType> targets = new List <TargetType> {
new TargetType(config.TargetTypeUri, subject.Session)
};
PublishInstruction publishInstruction = new PublishInstruction(subject.Session);
PublishEngine.Publish(items, publishInstruction, targets, ReiConfig.Priority);
}
else
{
Logger.Write("No items were published.", ReiConfig.Name, LoggingCategory.General, TraceEventType.Information);
}
}
/// <summary>
/// Gets the <see cref="T:Tridion.ContentManager.ContentManagement.Component"/> component specified by the ID
/// </summary>
/// <param name="ID"><see cref="T:Tridion.ContentManager.TcmUri"/></param>
/// <returns><see cref="T:Tridion.ContentManager.ContentManagement.Component"/></returns>
public Component GetComponent(TcmUri ID)
{
return(GetObject <Component>(ID));
}
/// <summary>
/// Initializes a new instance of the <see cref="Page"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal Page(Client client, TcmUri uri) : this(client, client.Read <PageData>(uri))
{
}
/// <summary>
/// Gets the <see cref="T:Tridion.ContentManager.CommunicationManagement.StructureGroup"/> specified by the ID
/// </summary>
/// <param name="ID"><see cref="T:Tridion.ContentManager.TcmUri"/></param>
/// <returns><see cref="T:Tridion.ContentManager.CommunicationManagement.StructureGroup"/></returns>
public StructureGroup GetStructureGroup(TcmUri ID)
{
return(GetObject <StructureGroup>(ID));
}
/// <summary>
/// Retrieves <see cref="T:Tridion.ContentDelivery.DynamicContent.BinaryData" />
/// </summary>
/// <param name="binaryUri">Binary <see cref="T:TcmCDService.Tridion.TcmUri" /></param>
/// <returns>
/// <see cref="T:Tridion.ContentDelivery.DynamicContent.BinaryData" /> or null
/// </returns>
internal static BinaryData GetBinaryData(TcmUri binaryUri)
{
return(GetBinaryData(binaryUri.PublicationId, binaryUri.ItemId));
}
public T GetContextIdentifiableObject <T>(TcmUri tcmUri) where T : IdentifiableObject
{
var contextTcmUri = TemplateUtilities.CreateTcmUriForPublication(this.Publication.Id.ItemId, tcmUri);
return(this.Engine.GetObject <T>(contextTcmUri));
}
private List <Component> GatherLinkedComponents(Component component)
{
_log.Debug($"Gathering linked components for component {component.Title}");
List <ItemFields> fieldList = new List <ItemFields>();
List <Component> components = new List <Component>();
if (component.Content != null)
{
fieldList.Add(new ItemFields(component.Content, component.Schema));
}
if (component.Metadata != null)
{
fieldList.Add(new ItemFields(component.Metadata, component.MetadataSchema));
}
var componentLinkFields = new List <ComponentLinkField>();
var embeddedSchemaFields = new List <EmbeddedSchemaField>();
foreach (var fields in fieldList)
{
foreach (var field in fields)
{
if (field is ComponentLinkField)
{
componentLinkFields.Add((ComponentLinkField)field);
}
if (field is EmbeddedSchemaField)
{
embeddedSchemaFields.Add((EmbeddedSchemaField)field);
}
}
}
for (int i = 0; i < embeddedSchemaFields.Count; i++)
{
EmbeddedSchemaField linkField = embeddedSchemaFields[i];
EmbeddedSchemaFieldDefinition linksFieldDefinition = linkField.Definition as EmbeddedSchemaFieldDefinition;
if (linksFieldDefinition?.EmbeddedSchema == null)
{
continue;
}
TcmUri id = linksFieldDefinition.EmbeddedSchema.Id; // force schema load
foreach (var embeddedFields in linkField.Values)
{
foreach (var embeddedField in embeddedFields)
{
if (embeddedField is ComponentLinkField)
{
componentLinkFields.Add((ComponentLinkField)embeddedField);
}
if (embeddedField is EmbeddedSchemaField)
{
embeddedSchemaFields.Add((EmbeddedSchemaField)embeddedField);
}
}
}
}
foreach (var linkField in componentLinkFields)
{
if (linkField.Values != null)
{
components.AddRange(linkField.Values);
}
}
return(components);
}
/// <summary>
/// Initializes a new instance of the <see cref="Category"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal Category(Client client, TcmUri uri) : this(client, client.Read <CategoryData>(uri))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ActivityInstance"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal ActivityInstance(Client client, TcmUri uri) : this(client, client.Read <ActivityInstanceData>(uri))
{
}
public Tridion.ContentDelivery.DynamicContent.Query.Query ToTridionQuery()
{
string[] basedOnSchemas = QuerySchemas;
DateTime lastPublishedDate = LastPublishedDate;
IList <MetaQueryItem> metaQueryItems = MetaQueryValues;
QueryLogic metaQueryLogic = MetaQueryLogic;
int maxmimumComponents = MaximumComponents;
Query q = null;
//PublicationCriteria publicationAndLastPublishedDateCriteria = new PublicationCriteria(PublicationId);
PublicationCriteria publicationAndLastPublishedDateCriteria = new PublicationCriteria(PublicationId);
//format DateTime // 00:00:00.000
ItemLastPublishedDateCriteria dateLastPublished = new ItemLastPublishedDateCriteria(lastPublishedDate.ToString("yyyy-MM-dd HH:mm:ss.fff"), Criteria.GreaterThanOrEqual);
//publicationAndLastPublishedDateCriteria.AddCriteria(dateLastPublished);
Criteria basedOnSchemaAndInPublication;
if (basedOnSchemas.Length > 0)
{
Criteria[] schemaCriterias = new Criteria[basedOnSchemas.Length];
int i = 0;
foreach (var schema in basedOnSchemas)
{
TcmUri schemaUri = new TcmUri(schema);
schemaCriterias.SetValue(new ItemSchemaCriteria(schemaUri.ItemId), i);
i++;
}
Criteria basedOnSchema = CriteriaFactory.Or(schemaCriterias);
basedOnSchemaAndInPublication = CriteriaFactory.And(publicationAndLastPublishedDateCriteria, basedOnSchema);
}
else
{
basedOnSchemaAndInPublication = publicationAndLastPublishedDateCriteria;
}
// Add filtering for meta data
Criteria schemasAndMetaData;
if (metaQueryItems.Count > 0)
{
Criteria metaQuery;
Criteria[] metaCriterias = new Criteria[metaQueryItems.Count];
int metaCount = 0;
foreach (MetaQueryItem queryItem in metaQueryItems)
{
CustomMetaKeyCriteria metaField = new CustomMetaKeyCriteria(queryItem.MetaField);
CustomMetaValueCriteria metaCriteria;
FieldOperator metaOperator = typeof(Criteria).GetField(queryItem.MetaOperator.ToString()).GetValue(null) as FieldOperator;
switch (queryItem.MetaValue.GetType().Name)
{
case "DateTime":
DateTime tempDate = (DateTime)queryItem.MetaValue;
metaCriteria = new CustomMetaValueCriteria(metaField, tempDate.ToString("yyyy-MM-dd HH:mm:ss.fff"), "yyyy-MM-dd HH:mm:ss.SSS", metaOperator);
break;
case "Float":
metaCriteria = new CustomMetaValueCriteria(metaField, (float)queryItem.MetaValue, metaOperator);
break;
case "String":
metaCriteria = new CustomMetaValueCriteria(metaField, queryItem.MetaValue as string, metaOperator);
break;
default:
throw new System.Exception("Unexpected query item data type; " + queryItem.MetaValue.GetType().Name);
}
metaCriterias.SetValue(metaCriteria, metaCount);
metaCount++;
}
if (MetaQueryLogic == QueryLogic.AllCriteriaMatch)
{
metaQuery = CriteriaFactory.And(metaCriterias);
}
else
{
metaQuery = CriteriaFactory.Or(metaCriterias);
}
schemasAndMetaData = CriteriaFactory.And(basedOnSchemaAndInPublication, metaQuery);
}
else
{
schemasAndMetaData = basedOnSchemaAndInPublication;
}
Criteria allConditions;
if (KeywordValues.Count > 0)
{
Criteria[] keywordCriterias = new Criteria[KeywordValues.Count];
int keywordCount = 0;
foreach (KeywordItem keyCriteria in KeywordValues)
{
TaxonomyKeywordCriteria keywordField = new TaxonomyKeywordCriteria(keyCriteria.CategoryUri, keyCriteria.KeywordUri, false);
keywordCriterias.SetValue(keywordField, keywordCount);
keywordCount++;
}
Criteria keyQuery;
if (KeywordQueryLogic == QueryLogic.AllCriteriaMatch)
{
keyQuery = CriteriaFactory.And(keywordCriterias);
}
else
{
keyQuery = CriteriaFactory.Or(keywordCriterias);
}
allConditions = CriteriaFactory.And(schemasAndMetaData, keyQuery);
}
else
{
allConditions = schemasAndMetaData;
}
q = new Query(allConditions);
if (maxmimumComponents != 0 && maxmimumComponents != int.MaxValue)
{
LimitFilter limitResults = new LimitFilter(maxmimumComponents);
q.SetResultFilter(limitResults);
}
// Sort column should either be a standard or custom metaData field
SortColumn paramSort;
if (typeof(SortParameter).GetField(QuerySortField) != null)
{
paramSort = typeof(SortParameter).GetField(QuerySortField).GetValue(null) as SortColumn;
}
else
{
// Why do we need to tell Tridion what data type the field is! Its in the database already!
paramSort = new CustomMetaKeyColumn(QuerySortField, typeof(MetadataType).GetField(SortType.ToString()).GetValue(null) as MetadataType);
}
SortDirection paramSortDirection = typeof(SortParameter).GetField(QuerySortOrder.ToString()).GetValue(null) as SortDirection;
SortParameter sortParameter = new SortParameter(paramSort, paramSortDirection);
q.AddSorting(sortParameter);
return(q);
}
/// <summary>
/// Initializes a new instance of the <see cref="SystemWideObject"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal SystemWideObject(Client client, TcmUri uri) : this(client, client.Read <SystemWideObjectData>(uri))
{
}
private static void Main(string[] args)
{
// Default execution options
Options options = new Options()
{
Mode = EngineMode.Debugger,
ItemURI = null,
TemplateURI = null,
PublicationTargetURI = null
};
InitializeConsole();
if (Parser.Default.ParseArguments(args, options))
{
LegacyInterface legacyInterface = null;
try
{
using (new PreviewServer())
{
// Initialize TcmDebugger.COM
legacyInterface = new LegacyInterface();
legacyInterface.SetProvider(new LegacyProvider());
switch (options.Mode)
{
case EngineMode.LocalServer:
using (new CompoundTemplateService2011())
{
Logger.Log(System.Diagnostics.TraceEventType.Information, "Press any key to exit.");
Console.ReadKey();
}
break;
case EngineMode.Debugger:
case EngineMode.Publisher:
if (String.IsNullOrEmpty(options.ItemURI))
{
throw new Exception("ItemUri is required for Debugger or Publisher engines");
}
if (!TcmUri.IsValid(options.ItemURI))
{
throw new Exception(String.Format("Invalid tcm uri {0}", options.ItemURI));
}
TcmUri tcmItemUri = new TcmUri(options.ItemURI);
if (tcmItemUri.ItemType != ItemType.Page || options.Mode != EngineMode.Publisher)
{
if (String.IsNullOrEmpty(options.TemplateURI))
{
throw new Exception("Template tcm uri is required for non-page type objects or debug engine");
}
if (!TcmUri.IsValid(options.TemplateURI))
{
throw new Exception(String.Format("Invalid template tcm uri {0}", options.TemplateURI));
}
}
if (!String.IsNullOrEmpty(options.PublicationTargetURI) && !TcmUri.IsValid(options.PublicationTargetURI))
{
throw new Exception(String.Format("Invalid publication target tcm uri {0}", options.TemplateURI));
}
Engine engine = null;
switch (options.Mode)
{
case EngineMode.Debugger:
engine = new Engines.DebugEngine();
break;
case EngineMode.Publisher:
engine = new RenderEngine();
break;
}
String output = engine.Execute(options.ItemURI, options.TemplateURI, options.PublicationTargetURI);
output += "";
Console.WriteLine();
Console.WriteLine("{0} [!] {1}", DateTime.Now.ToString("HH:mm:ss"), "Execution finished. Press any key to exit.");
Console.ReadKey();
break;
}
}
}
catch (Exception ex)
{
Logger.Log(System.Diagnostics.TraceEventType.Error, ex.Message);
}
finally
{
if (legacyInterface != null)
{
Marshal.ReleaseComObject(legacyInterface);
}
}
}
}
public IPage GetPage(TcmUri pageId)
{
var page = _pageFactory.GetPage(pageId.ToString());
return(page);
}
/// <summary>
/// Initializes a new instance of the <see cref="ApprovalStatus"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal ApprovalStatus(Client client, TcmUri uri) : this(client, client.Read <ApprovalStatusData>(uri))
{
}
/// <summary>
/// Writes a <see cref="T:Tridion.ContentManager.TcmUri" /> value to a XML element
/// </summary>
/// <param name="writer"><see cref="T:System.Xml.XmlWriter" />.</param>
/// <param name="localName">Node Name.</param>
/// <param name="value"><see cref="T:Tridion.ContentManager.TcmUri" /> value</param>
/// <remarks>Only the TcmUri.ItemId is written as publishing is already publication specific</remarks>
public static void WriteAttributeOptional(this XmlWriter writer, String localName, TcmUri value)
{
if (writer != null && value != null)
{
writer.WriteAttributeString(localName, value);
}
}
/// <summary>
/// Retrieves <see cref="T:Tridion.ContentDelivery.DynamicContent.BinaryData" />
/// </summary>
/// <param name="binaryUri">Binary <see cref="T:TcmCDService.Tridion.TcmUri" /></param>
/// <param name="variantId">Binary variantId as <see cref="T:System.String" /></param>
/// <returns>
/// <see cref="T:Tridion.ContentDelivery.DynamicContent.BinaryData" /> or null
/// </returns>
internal static BinaryData GetBinaryData(TcmUri binaryUri, String variantId)
{
return(GetBinaryData(binaryUri.PublicationId, binaryUri.ItemId, variantId));
}
public static XElement GetListXml(this TcmUri tcmUri, ItemType itemType, bool recursive)
{
ItemType[] list = { itemType };
return(GetListXml(tcmUri, list, recursive));
}
private static string GetPublicationUri(TcmUri tcmUri, Localization localization)
=> (localization == null) ? $"tcm:0-{tcmUri.PublicationId}-1" : localization.GetCmUri();
/// <summary>
/// Initializes a new instance of the <see cref="Trustee"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal Trustee(Client client, TcmUri uri) : this(client, client.Read <TrusteeData>(uri))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PublicationTarget"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal PublicationTarget(Client client, TcmUri uri) : this(client, client.Read <PublicationTargetData>(uri))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualFolder"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal VirtualFolder(Client client, TcmUri uri) : this(client, client.Read <VirtualFolderData>(uri))
{
}
/// <summary>
/// Deletes the object for the specified <see cref="T:TcmCoreService.Misc.TcmUri" /> from Tridion
/// </summary>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal void Delete(TcmUri uri)
{
mClient.Delete(uri);
}
/// <summary>
/// Gets the <see cref="T:Tridion.ContentManager.CommunicationManagement.ComponentTemplate"/> specified by the ID
/// </summary>
/// <param name="ID"><see cref="T:Tridion.ContentManager.TcmUri"/></param>
/// <returns><see cref="T:Tridion.ContentManager.CommunicationManagement.ComponentTemplate"/></returns>
public ComponentTemplate GetComponentTemplate(TcmUri ID)
{
return(GetObject <ComponentTemplate>(ID));
}
/// <summary>
/// UnLocalize the specified <see cref="T:Tridion.ContentManager.CoreService.IdentifiableObjectData" /> derived class
/// in Tridion
/// </summary>
/// <typeparam name="T"><see cref="T:Tridion.ContentManager.CoreService.IdentifiableObjectData" /> derived class</typeparam>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
/// <param name="readOptions"><see cref="T:Tridion.ContentManager.CoreService.Client.ReadOptions"/></param>
/// <returns><see cref="T:Tridion.ContentManager.CoreService.IdentifiableObjectData" /> derived class</returns>
internal T UnLocalize <T>(TcmUri uri, ReadOptions readOptions) where T : IdentifiableObjectData
{
return(mClient.UnLocalize(uri, readOptions) as T);
}
/// <summary>
/// Gets the <see cref="T:Tridion.ContentManager.CommunicationManagement.Page"/> specified by the ID
/// </summary>
/// <param name="ID"><see cref="T:Tridion.ContentManager.TcmUri"/></param>
/// <returns><see cref="T:Tridion.ContentManager.CommunicationManagement.Page"/></returns>
public Page GetPage(TcmUri ID)
{
return(GetObject <Page>(ID));
}
/// <summary>
/// Initializes a new instance of the <see cref="Group"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal Group(Client client, TcmUri uri) : this(client, client.Read <GroupData>(uri))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TargetType"/> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="uri"><see cref="T:TcmCoreService.Misc.TcmUri" /></param>
internal TargetType(Client client, TcmUri uri) : this(client, client.Read <TargetTypeData>(uri))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TransformXml"/> class.
/// </summary>
/// <param name="engine"><see cref="T:Tridion.ContentManager.Templating.Engine" /></param>
/// <param name="package"><see cref="T:Tridion.ContentManager.Templating.Package" /></param>
/// <param name="templateBase"><see cref="T:TcmTemplating.TemplateBase" /></param>
/// <param name="templateBuildingBlock">Tridion template building block to use as source</param>
public TransformXml(Engine engine, Package package, TemplateBase templateBase, TcmUri templateBuildingBlockUri) : this(engine, package, templateBase)
{
if (templateBuildingBlockUri.ItemType != ItemType.TemplateBuildingBlock)
{
throw new ArgumentException("templateBuildingBlock is not ItemType.TemplateBuildingBlock");
}
TemplateBuildingBlock templateBuildingBlock = engine.GetObject(templateBuildingBlockUri) as TemplateBuildingBlock;
String content = templateBuildingBlock.Content.Replace("tcm:include", "xsl:include");
using (StringReader sr = new StringReader(content))
{
using (XmlReader reader = XmlReader.Create(sr))
{
mXslCompiledTransform.Load(reader, XsltSettings, new XmlTcmUriResolver(engine));
}
}
}
public bool Contains(TcmUri uri)
{
XmlNode node = m_TridionList.SelectSingleNode(String.Format("//tcm:{0}[@ID = '{1}']", ItemXmlName, uri.ToString()), NSManager);
return(node != null);
}
