/// <summary>
/// Check the Publishing queue and determine whether the given TcmUri is already present in the queue.
/// </summary>
/// <param name="engine">Engine object</param>
/// <param name="tcmUri">String representing the tcmuri of the item to check</param>
/// <param name="state">PublishTransactionState the publish state to filter on</param>
public static bool IsInPublishingQueue(Engine engine, String tcmUri, PublishTransactionState state)
{
Log.Debug(String.Format("Check Publishing queue for item '{0}'", tcmUri));
Session session = engine.GetSession();
PublishTransactionsFilter filter = new PublishTransactionsFilter(session);
filter.PublishTransactionState = state;
RepositoryLocalObject item = engine.GetObject(tcmUri) as RepositoryLocalObject;
if (item != null)
{
filter.ForRepository = item.ContextRepository;
}
PublicationTarget publicationTarget = engine.PublishingContext.PublicationTarget;
if (publicationTarget != null)
{
filter.PublicationTarget = publicationTarget;
}
XmlElement element = PublishEngine.GetListPublishTransactions(filter);
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace("tcm", "http://www.tridion.com/ContentManager/5.0");
String xPath = String.Format("tcm:ListPublishTransactions/tcm:Item[@ItemID='{0}']", tcmUri);
XmlNodeList nodeList = element.SelectNodes(xPath, namespaceManager);
return(nodeList.Count > 0);
}
/// <summary>
/// Audits the object unlocalizations
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="UnLocalizeEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditUnLocalize(RepositoryLocalObject repositoryObject, UnLocalizeEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
{
AuditContentEdit("UnLocalize", repositoryObject, null, new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
}
/// <summary>
/// Returns a list of Components representing all encountered configurations that were found according to the locations in the .config file
/// </summary>
private List <Component> GetConfigurationComponents(RepositoryLocalObject repositoryLocalObject)
{
List <Component> results = new List <Component>();
Component configurationComponent = null;
foreach (string location in SystemComponentLocation.Split(','))
{
try
{
if (location == PUBLICATION) // read from Publication metadata
{
Repository publication = repositoryLocalObject.ContextRepository;
results.AddRange(GetConfigurationsFromMetadata(publication.Metadata, publication.MetadataSchema));
}
else if (location == CURRENT) // read from parent metadata
{
OrganizationalItem organizationalItem = repositoryLocalObject.OrganizationalItem;
results.AddRange(GetConfigurationsFromStructureGroup(organizationalItem, SystemComponentRecursive));
}
else if (location.StartsWith("/webdav") || TcmUri.IsValid(location))
{
configurationComponent = (Component)repositoryLocalObject.Session.GetObject(location);
results.Add(configurationComponent);
}
}
catch
{
// Log error
}
}
return(results);
}
/// <summary>
/// Audits object version rollbacks.
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="RollbackEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditRollback(RepositoryLocalObject repositoryObject, RollbackEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
{
AuditContentEdit("Rollback", repositoryObject, String.Format("Delete Versions: {0}", args.DeleteVersions), new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
}
/// <summary>
/// Audits the purging of old versions
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="PurgeOldVersionsEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditPurgeOldVersions(RepositoryLocalObject repositoryObject, PurgeOldVersionsEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
{
AuditContentEdit("PurgeVersions", repositoryObject, null, null);
}
}
private void FindDataPresentationTemplate()
{
RepositoryLocalObject sourceItem = (RepositoryLocalObject)RenderedItem.ResolvedItem.Item;
Publication contextPublication = (Publication)sourceItem.ContextRepository;
ComponentTemplatesFilter ctFilter = new ComponentTemplatesFilter(Session)
{
AllowedOnPage = false,
BaseColumns = ListBaseColumns.IdAndTitle
};
// TODO: use marker App Data instead of the CTs Title.
const string dataPresentationTemplateTitle = "Generate Data Presentation";
_dataPresentationTemplate = contextPublication.GetComponentTemplates(ctFilter).FirstOrDefault(ct => ct.Title == dataPresentationTemplateTitle);
if (_dataPresentationTemplate == null)
{
Logger.Warning($"Component Template '{dataPresentationTemplateTitle}' not found.");
_dataPresentationTemplateNotFound = true;
}
else
{
Logger.Debug($"Found Data Presentation Template: {_dataPresentationTemplate.FormatIdentifier()}");
}
}
public static ItemFields MetaFields(this RepositoryLocalObject component)
{
return
(null != component.Metadata
? new ItemFields(component.Metadata, component.MetadataSchema)
: component.MetadataSchema.IfNotNull(meta => new ItemFields(meta)));
}
/// <summary>
/// Gets metadata field recursively for the given fieldName.
/// </summary>
/// <typeparam name="T">ItemField or a derived type.</typeparam>
/// <param name="repositoryLocalObject">RepositoryLocalObject object.</param>
/// <param name="fieldPath">Metadata field name.</param>
/// <returns>Object of the given type.</returns>
public static T GetMetadataFieldRecursive <T>(this RepositoryLocalObject repositoryLocalObject, string fieldPath)
where T : ItemField
{
T itemField = null;
while (true)
{
var metadata = repositoryLocalObject.GetMetadataFields();
if (metadata != null)
{
itemField = metadata.GetField <T>(fieldPath);
}
if (!itemField.HasValue())
{
if (
!(repositoryLocalObject is OrganizationalItem &&
((OrganizationalItem)repositoryLocalObject).IsRootOrganizationalItem))
{
repositoryLocalObject = repositoryLocalObject.OrganizationalItem;
continue;
}
}
break;
}
return(itemField);
}
/// <summary>
/// Checks if the current configuration needs to be reloaded. If so, it performs the reloads.
/// </summary>
private void ReloadIfModified(RepositoryLocalObject repositoryLocalObject)
{
DateTime dateTimeNow = DateTime.Now;
DateTime lastModifiedCheck = instance.LastModifiedCheck;
DateTime expiredDateTime = lastModifiedCheck.AddMinutes(SystemComponentCacheMinutes);
if (dateTimeNow > expiredDateTime) // check for modifications
{
IEnumerable <Component> configurationComponents = GetConfigurationComponents(repositoryLocalObject); // 'expensive' call
bool isReload = false;
foreach (Component configurationComponent in configurationComponents)
{
if (configurationComponent.RevisionDate > lastModifiedCheck)
{
isReload = true;
break;
}
}
if (isReload)
{
_configurations.Clear();
foreach (Component configurationComponent in configurationComponents)
{
instance.Load(configurationComponent); // even more 'expensive' call
}
}
LastModifiedCheck = dateTimeNow;
}
}
/// <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>
private static PublishTransaction FindPublishTransaction(Engine engine, String tcmUri)
{
Log.Debug(String.Format("Find PublishTransaction for item '{0}'", tcmUri));
PublishTransaction result = null;
Session session = engine.GetSession();
PublishTransactionsFilter filter = new PublishTransactionsFilter(session);
filter.PublishTransactionState = PublishTransactionState.Resolving;
RepositoryLocalObject item = engine.GetObject(tcmUri) as RepositoryLocalObject;
if (item != null)
{
filter.ForRepository = item.ContextRepository;
}
PublicationTarget publicationTarget = engine.PublishingContext.PublicationTarget;
if (publicationTarget != null)
{
filter.PublicationTarget = publicationTarget;
}
XmlElement element = PublishEngine.GetListPublishTransactions(filter);
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace("tcm", "http://www.tridion.com/ContentManager/5.0");
String xPath = String.Format("tcm:ListPublishTransactions/tcm:Item[@ItemID='{0}']", tcmUri);
XmlNodeList nodeList = element.SelectNodes(xPath, namespaceManager);
String transactionId;
if (nodeList != null && nodeList.Count == 1)
{
transactionId = nodeList[0].Attributes["ID"].Value;
TcmUri transactionUri = new TcmUri(transactionId);
result = new PublishTransaction(transactionUri, session);
}
else
{
foreach (XmlNode node in element.ChildNodes)
{
transactionId = node.Attributes["ID"].Value;
TcmUri transactionUri = new TcmUri(transactionId);
result = new PublishTransaction(transactionUri, session);
if (IsPublishTransactionForTcmUri(result, tcmUri))
{
break;
}
result = null;
}
}
Log.Debug("Returning PublishTransaction " + result);
return(result);
}
/// <summary>
/// Prepare index data for any item metadata
/// </summary>
/// <param name="item">The item to process</param>
/// <param name="settings">Field processor settings</param>
public virtual void ProcessMetadata(RepositoryLocalObject item, FieldProcessorSettings settings)
{
if (item.Metadata != null)
{
ItemFields fields = new ItemFields(item.Metadata, item.MetadataSchema);
_processor.ProcessData(fields, settings);
}
}
/// <summary>
/// Returns the metadata <see cref="T:Tridion.ContentManager.ContentManagement.Fields.ItemFields" /> for the
/// <see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" />
/// </summary>
/// <param name="repositoryLocalObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <returns><see cref="T:Tridion.ContentManager.ContentManagement.Fields.ItemFields" /></returns>
public static ItemFields MetadataFields(this RepositoryLocalObject repositoryLocalObject)
{
if (repositoryLocalObject != null)
{
return(ItemFieldsFactory.Get(repositoryLocalObject, repositoryLocalObject.Metadata, repositoryLocalObject.MetadataSchema));
}
return(null);
}
/// <summary>
/// Returns the last publish date in the current <see cref="T:Tridion.ContentManager.CommunicationManagement.Publication" /> and
/// current <see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget"/>
/// </summary>
/// <param name="repositoryLocalObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="engine"><see cref="T:Tridion.ContentManager.Templating.Engine" /></param>
/// <returns>Returns <see cref="T:System.DateTime"/> or DateTime.MinValue</returns>
public static DateTime PublishedAt(this RepositoryLocalObject repositoryLocalObject, Engine engine)
{
if (engine.RenderMode == RenderMode.Publish)
{
return(repositoryLocalObject.PublishedAt(repositoryLocalObject.ContextRepository as Publication, engine.PublishingContext.PublicationTarget));
}
return(default(DateTime));
}
/// <summary>
/// Returns the metadata <see cref="T:Tridion.ContentManager.ContentManagement.Schema" /> this <see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /> is using.
/// </summary>
/// <param name="repositoryLocalObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <returns>Metadata <see cref="T:Tridion.ContentManager.ContentManagement.Schema" /> root element name or <c>String.Empty</c></returns>
public static String UsingMetadataSchema(this RepositoryLocalObject repositoryLocalObject)
{
if (repositoryLocalObject.MetadataSchema != null)
{
return(repositoryLocalObject.MetadataSchema.RootElementName);
}
return(String.Empty);
}
/// <summary>
/// Returns the ConfigurationManager singleton object. It also checks to reload the Configuration Component vales, if needed.
/// </summary>
/// <param name="repositoryLocalObject">the current object to check reloading configuration values for</param>
/// <returns>the singleton ConfigurationManager object</returns>
public static ConfigurationManager GetInstance(RepositoryLocalObject repositoryLocalObject)
{
if (instance == null)
{
instance = new ConfigurationManager();
}
instance.ReloadIfModified(repositoryLocalObject);
return(instance);
}
private XElement CreateNavigationStructure(RepositoryLocalObject current)
{
//Validate Structure group name, only for the first level
if (current is StructureGroup && !ValidateStructureGroupName(current as StructureGroup))
{
return(null);
}
//Ignore some pages based in their page template.
if (current is Page && IgnorePageTemplate(current as Page))
{
return(null);
}
var item = BuildStrucutreItem(current);
if (item == null)
{
return(null);
}
if (current is Page)
{
return(item);
}
//validation to only list the children of root (home) strucutu group.
if (OnlyFirstLevel && !current.Title.Equals(publication.RootStructureGroup.Title))
{
return(item);
}
var children = GetStructureGroupItems(current as StructureGroup);
if (children != null && !children.Any())
{
return(item);
}
foreach (var child in children)
{
var childItem = CreateNavigationStructure(child as RepositoryLocalObject);
if (childItem != null)
{
item.Add(childItem);
}
}
return(item);
}
protected string GetPageOrStructureGroupTitle(RepositoryLocalObject pageOrSg)
{
if (pageOrSg is Page)
{
return(GetPageTitle(pageOrSg as Page));
}
else
{
return(GetStructureGroupTitle(pageOrSg as StructureGroup));
}
}
public static IEnumerable <OrganizationalItem> Parents(this RepositoryLocalObject page)
{
var sg = page.OrganizationalItem;
while (null != sg.OrganizationalItem)
{
yield return(sg);
sg = sg.OrganizationalItem;
}
}
/// <summary>
/// Gets the context Publication.
/// </summary>
/// <returns>The context Publication.</returns>
protected Publication GetPublication()
{
RepositoryLocalObject inputItem = (RepositoryLocalObject)GetPage() ?? GetComponent();
if (inputItem == null)
{
throw new DxaException("Unable to determine the context Publication.");
}
return((Publication)inputItem.ContextRepository);
}
protected List <KeyValuePair <TcmUri, string> > GetUsingItems(RepositoryLocalObject subject, ItemType itemType)
{
UsingItemsFilter filter = new UsingItemsFilter(Engine.GetSession())
{
ItemTypes = new List <ItemType> {
itemType
},
BaseColumns = ListBaseColumns.IdAndTitle
};
return(XmlElementToTcmUriList(subject.GetListUsingItems(filter)));
}
private string GetTitle(RepositoryLocalObject item)
{
var match = Regex.Match(item.Title, StructureGroupValidationPattern);
if (match.Groups.Count > 1)//if it has the patter 01-1-xxxx, it will remove the 01-1-
{
return(match.Groups[1].Value);
}
else
{
return(item.Title);
}
}
/// <summary>
/// Audits object or version deletions
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="DeleteEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditDelete(RepositoryLocalObject repositoryObject, DeleteEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
{
// Discern between deleting objects and deleting object versions
if (repositoryObject.Id.IsVersionless)
{
AuditContentEdit("Delete", repositoryObject, null, new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
else
{
AuditContentEdit("DeleteVersion", repositoryObject, null, new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
}
}
protected string GetModuleNameFromItem(RepositoryLocalObject item, string moduleRoot)
{
//The module name is the name of the folder within the first level of the module root folder
//in which the item lives
string fullItemWebdavUrl = item.WebDavUrl;
if (fullItemWebdavUrl.StartsWith(moduleRoot))
{
Logger.Debug(fullItemWebdavUrl + ":" + moduleRoot);
string res = fullItemWebdavUrl.Substring(moduleRoot.Length + 1);
int pos = res.IndexOf("/", StringComparison.Ordinal);
Logger.Debug(res);
return(res.Substring(0, pos).ToLower());
}
return(null);
}
/// <summary>
/// Performs the actual transformation logic of this <see cref="PageVariables" />.
/// </summary>
/// <remarks>
/// Transform is the main entry-point for template functionality.
/// </remarks>
protected override void Transform()
{
Package.AddString(PackagePrefix + ".Uri", Page.Id);
IEnumerable <String> metadataFields = new String[] { };
IEnumerable <String> inheritedFields = new String[] { };
String value = Package.ItemAsString("MetadataFields");
if (!String.IsNullOrWhiteSpace(value))
{
metadataFields = value.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
}
value = Package.ItemAsString("InheritedFields");
if (!String.IsNullOrWhiteSpace(value))
{
inheritedFields = value.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
}
// Extract page metadata fields
ParseFields(metadataFields.Concat(inheritedFields), Page.MetadataFields());
// If the page is a navigable item, register it
if (Page.NavigableNumber() > 0)
{
Package.AddString(PackagePrefix + ".NavigationParent", Page.Id);
}
RepositoryLocalObject item = Page.OrganizationalItem;
while (item != null && item.Id != Publication.Id)
{
// Found navigable item and no navparent value is set yet.
if (item.NavigableNumber() > 0 && Package.GetByName(PackagePrefix + ".NavigationParent") == null)
{
Package.AddString(PackagePrefix + ".NavigationParent", item.Id);
}
// Extract inherited fields
ParseFields(inheritedFields, item.MetadataFields());
item = item.OrganizationalItem;
}
}
/// <summary>
/// Check if an item (typically a page, CT or PT) is indexed by looking for standard metadata fields
/// </summary>
/// <param name="item">Item to be indexed</param>
/// <returns>true if it should be indexed</returns>
public static bool IsIndexed(this RepositoryLocalObject item)
{
if (item.Metadata != null)
{
string noIndex = GetFieldValue(item.Metadata, Constants.FIELD_NOINDEX);
if (noIndex != null && noIndex.ToLower() == "yes")
{
return(false);
}
}
//Recursive check for Structure Groups and Folders
if (item is OrganizationalItem && item.OrganizationalItem != null && item.OrganizationalItem.Id.ItemId != item.Id.ItemId)
{
return(item.OrganizationalItem.IsIndexed());
}
return(true);
}
//private Engine _engine;
private static Publication GetPublication(Engine engine, Package package)
{
RepositoryLocalObject pubItem = null;
Repository repository = null;
if (package.GetByType(ContentType.Page) != null)
{
pubItem = GetPage(engine, package);
}
else
{
pubItem = GetComponent(engine, package);
}
if (pubItem != null)
{
repository = pubItem.ContextRepository;
}
return(repository as Publication);
}
private string GetFriendlyPageUrl(RepositoryLocalObject current)
{
//Only for pages
if (current is StructureGroup)
{
return(null);
}
if (current.Metadata == null || current.MetadataSchema == null)
{
return(null);
}
var meta = new ItemFields(current.Metadata, current.MetadataSchema);
//Get the Embedded navigation Metadata
var friendlyUrl = meta.Text("SEOUrl");
return(!string.IsNullOrEmpty(friendlyUrl) ? friendlyUrl : null);
}
/// <summary>
/// Returns the publication object that can be determined from the package for this template.
/// </summary>
/// <remarks>
/// This method currently depends on a Page item being available in the package, meaning that
/// it will only work when invoked from a Page Template.
///
/// </remarks>
/// <returns>the Publication object that can be determined from the package for this template.</returns>
protected Publication GetPublication()
{
CheckInitialized();
RepositoryLocalObject pubItem = null;
Repository repository = null;
if (m_Package.GetByType(ContentType.Page) != null)
{
pubItem = GetPage();
}
else
{
pubItem = GetComponent();
}
if (pubItem != null)
{
repository = pubItem.ContextRepository;
}
return(repository as Publication);
}
/// <summary>
/// Returns the publication object that can be determined from the package for this template.
/// </summary>
/// <remarks>
/// This method currently depends on a Page item being available in the package, meaning that
/// it will only work when invoked from a Page Template.
///
/// Updated by Kah Tan ([email protected])
/// </remarks>
/// <returns>the Publication object that can be determined from the package for this template.</returns>
public static Publication GetPublication(this IExtendibleTemplate template)
{
template.CheckInitialized();
RepositoryLocalObject pubItem = null;
Repository repository = null;
if (template.Package.GetByType(ContentType.Page) != null)
{
pubItem = template.GetPage();
}
else
{
pubItem = template.GetComponent();
}
if (pubItem != null)
{
repository = pubItem.ContextRepository;
}
return(repository as Publication);
}
public void Transform(Engine engine, Package package)
{
_log = TemplatingLogger.GetLogger(GetType());
RepositoryLocalObject context =
engine.GetObject(package.GetByName(Package.PageName)) as RepositoryLocalObject;
if (context == null)
{
_log.Error("Could not retrieve page from package. Exiting.");
return;
}
string categoryUrl = context.ContextRepository.WebDavUrl + NavigationCategoryWebDavUrl;
Category navigation = (Category)engine.GetObject(categoryUrl);
using (MemoryStream ms = new MemoryStream())
{
XmlTextWriter w = new XmlTextWriter(ms, new UTF8Encoding(false))
{
Indentation = 4,
Formatting = Formatting.Indented
};
w.WriteStartDocument();
w.WriteStartElement(Navigation.RootNodeName);
KeywordsFilter filter = new KeywordsFilter(engine.GetSession())
{
IsRoot = true
};
foreach (XmlNode rootChildren in navigation.GetListKeywords(filter))
{
Keyword rootKeyword = (Keyword)engine.GetObject(rootChildren.Attributes["ID"].Value);
w.WriteStartElement(Navigation.NodeName);
NavigationNode n = new NavigationNode(rootKeyword);
}
}
}
/// <summary>
/// Processes (recursively) the navigation.
/// </summary>
/// <param name="writer">The XmlTextWriter to use.</param>
/// <param name="item">The item.</param>
private void ProcessNavigation(XmlTextWriter writer, RepositoryLocalObject item)
{
Match match = _regex.Match(item.Title);
bool isStructureGroup = (item is StructureGroup);
// Exit if the current item has no numbers in its title.
if (Navigation.OnlyIncludeItemsWithNumbersInTitle && !match.Success) return;
if (!isStructureGroup)
item = GetApprovedVersionForTarget((Page)item, _engine.PublishingContext.PublicationTarget);
// Get the correct item title, without numbers
string itemTitle = Regex.Replace(item.Title, RegexPattern, string.Empty);
// Get the correct item path
string itemPath = isStructureGroup ? ((StructureGroup)item).PublishLocationUrl : ((Page)item).PublishLocationUrl;
// Add / where it needs to be added
if ((!itemPath.EndsWith("/")) && (isStructureGroup)) itemPath += "/";
if (!itemPath.StartsWith("/")) itemPath = "/" + itemPath;
writer.WriteStartElement(Navigation.NodeName);
writer.WriteAttributeString(Navigation.TypeAttributeName, item.Id.ItemType.ToString());
if (Navigation.IncludePathAttribute) writer.WriteAttributeString(Navigation.PathAttributeName, itemPath);
writer.WriteAttributeString(Navigation.TitleAttributeName, itemTitle);
if (Navigation.IncludeUriAttribute) writer.WriteAttributeString(Navigation.UriAttributeName, item.Id);
if (isStructureGroup)
{
_countStructureGroups++;
if (Navigation.IncludeStructureGroupMedata)
{
if (item.Metadata != null)
{
ItemFields itemMetadata = new ItemFields(item.Metadata, item.MetadataSchema);
AddMetadataAttributes(itemMetadata, writer);
}
}
foreach (RepositoryLocalObject child in ((StructureGroup)item).GetItems())
{
ProcessNavigation(writer, child);
}
}
else
{
_countPages++;
if (Navigation.IncludePageMetadata)
{
if (item.Metadata != null)
{
ItemFields itemMetadata = new ItemFields(item.Metadata, item.MetadataSchema);
AddMetadataAttributes(itemMetadata, writer);
}
}
}
writer.WriteEndElement();
}
protected string GetPageOrStructureGroupTitle(RepositoryLocalObject pageOrSg) {
if (pageOrSg is Page)
return GetPageTitle(pageOrSg as Page);
else
return GetStructureGroupTitle(pageOrSg as StructureGroup);
}
/// <summary>
/// Prepare index data for any item metadata
/// </summary>
/// <param name="item">The item to process</param>
/// <param name="settings">Field processor settings</param>
public virtual void ProcessMetadata(RepositoryLocalObject item, FieldProcessorSettings settings)
{
if (item.Metadata != null)
{
ItemFields fields = new ItemFields(item.Metadata, item.MetadataSchema);
_processor.ProcessData(fields, settings);
}
}
protected string GetModuleNameFromItem(RepositoryLocalObject item, string moduleRoot)
{
//The module name is the name of the folder within the first level of the module root folder
//in which the item lives
string fullItemWebdavUrl = item.WebDavUrl;
if (fullItemWebdavUrl.StartsWith(moduleRoot))
{
Logger.Debug(fullItemWebdavUrl + ":" + moduleRoot);
string res = fullItemWebdavUrl.Substring(moduleRoot.Length + 1);
int pos = res.IndexOf("/", StringComparison.Ordinal);
Logger.Debug(res);
return res.Substring(0, pos).ToLower();
}
return null;
}
/// <summary>
/// Audits object version rollbacks.
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="RollbackEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditRollback(RepositoryLocalObject repositoryObject, RollbackEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
AuditContentEdit("Rollback", repositoryObject, String.Format("Delete Versions: {0}", args.DeleteVersions), new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
/// <summary>
/// Returns a list of Components representing all encountered configurations that were found according to the locations in the .config file
/// </summary>
private List<Component> GetConfigurationComponents(RepositoryLocalObject repositoryLocalObject)
{
List<Component> results = new List<Component>();
Component configurationComponent = null;
foreach (string location in SystemComponentLocation.Split(','))
{
try
{
if (location == PUBLICATION) // read from Publication metadata
{
Repository publication = repositoryLocalObject.ContextRepository;
results.AddRange(GetConfigurationsFromMetadata(publication.Metadata, publication.MetadataSchema));
}
else if (location == CURRENT) // read from parent metadata
{
OrganizationalItem organizationalItem = repositoryLocalObject.OrganizationalItem;
results.AddRange(GetConfigurationsFromStructureGroup(organizationalItem, SystemComponentRecursive));
}
else if (location.StartsWith("/webdav") || TcmUri.IsValid(location))
{
configurationComponent = (Component)repositoryLocalObject.Session.GetObject(location);
results.Add(configurationComponent);
}
}
catch
{
// Log error
}
}
return results;
}
/// <summary>
/// Enhance the XmlElement corresponding to a SG or Page with information such as ID and Title.
/// </summary>
/// <param name="item">XmlElement to be enhanced</param>
/// <param name="rlo">RepositoryLocalObject representing either SG or Page to enhance from</param>
private void EnhanceNode(XmlElement item, RepositoryLocalObject rlo) {
item.SetAttribute(ATTRIBUTE_ID, rlo.Id);
item.SetAttribute(ATTRIBUTE_TITLE, rlo.Title);
}
protected void OutputMetdataFields(RepositoryLocalObject item, StringBuilder sb)
{
if (item.Metadata != null )
{
ItemFields metadata = this.GetMetaData(item);
if (metadata.Count() > 0)
{
sb.Append("<metadata>\n");
this.OutputFields(metadata, sb, true);
sb.Append("</metadata>\n");
}
}
}
/// <summary>
/// Check if current Tridion item is published to specified publication target
/// </summary>
/// <param name="item"></param>
/// <param name="publicationTarget"></param>
/// <returns></returns>
protected bool IsPublishedToTarget(RepositoryLocalObject item, PublicationTarget publicationTarget)
{
Boolean isPublished = false;
ICollection<PublishInfo> publishInfoList = PublishEngine.GetPublishInfo(item);
foreach (PublishInfo publishInfo in publishInfoList)
{
if (publishInfo.PublicationTarget.Equals(publicationTarget))
{
isPublished = true;
break;
}
}
return isPublished;
}
protected ItemFields GetMetaData(RepositoryLocalObject item)
{
if (item.Metadata == null) { return null; }
ItemFields metadataFields = new ItemFields(item.Metadata, item.MetadataSchema);
return metadataFields;
}
/// <summary>
/// Audits object or version deletions
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="DeleteEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditDelete(RepositoryLocalObject repositoryObject, DeleteEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
// Discern between deleting objects and deleting object versions
if (repositoryObject.Id.IsVersionless)
AuditContentEdit("Delete", repositoryObject, null, new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
else
AuditContentEdit("DeleteVersion", repositoryObject, null, new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
/// <summary>
/// Audits the purging of old versions
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="PurgeOldVersionsEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditPurgeOldVersions(RepositoryLocalObject repositoryObject, PurgeOldVersionsEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
AuditContentEdit("PurgeVersions", repositoryObject, null, null);
}
/// <summary>
/// Returns the ConfigurationManager singleton object. It also checks to reload the Configuration Component vales, if needed.
/// </summary>
/// <param name="repositoryLocalObject">the current object to check reloading configuration values for</param>
/// <returns>the singleton ConfigurationManager object</returns>
public static ConfigurationManager GetInstance(RepositoryLocalObject repositoryLocalObject)
{
if (instance == null)
{
instance = new ConfigurationManager();
}
instance.ReloadIfModified(repositoryLocalObject);
return instance;
}
/// <summary>
/// Checks if the current configuration needs to be reloaded. If so, it performs the reloads.
/// </summary>
private void ReloadIfModified(RepositoryLocalObject repositoryLocalObject)
{
DateTime dateTimeNow = DateTime.Now;
DateTime lastModifiedCheck = instance.LastModifiedCheck;
DateTime expiredDateTime = lastModifiedCheck.AddMinutes(SystemComponentCacheMinutes);
if (dateTimeNow > expiredDateTime) // check for modifications
{
IEnumerable<Component> configurationComponents = GetConfigurationComponents(repositoryLocalObject); // 'expensive' call
bool isReload = false;
foreach (Component configurationComponent in configurationComponents)
{
if (configurationComponent.RevisionDate > lastModifiedCheck)
{
isReload = true;
break;
}
}
if (isReload)
{
_configurations.Clear();
foreach (Component configurationComponent in configurationComponents)
{
instance.Load(configurationComponent); // even more 'expensive' call
}
}
LastModifiedCheck = dateTimeNow;
}
}
/// <summary>
/// Initializes a new instance of the <see>
/// <cref>TridionOutputHandler</cref>
/// </see>
/// class.
/// </summary>
/// <param name="tcmUri">The TCM URI.</param>
/// <param name="engine">The engine.</param>
/// <param name="package">The package.</param>
public FieldOutputHandler(TcmUri tcmUri, Engine engine, Package package)
{
if (!TcmUri.IsValid(tcmUri.ToString()))
{
Log.Error(tcmUri + " is not a valid URI. Failed to initialize Output Handler!");
}
else
{
switch (tcmUri.ItemType)
{
case ItemType.Component:
try
{
_component = new Component(tcmUri, engine.GetSession());
_currentItem = _component;
if (_component.ComponentType == ComponentType.Normal)
{
_contentFields = new ItemFields(_component.Content, _component.Schema);
}
if (_component.Metadata != null)
_metadataFields = new ItemFields(_component.Metadata, _component.Schema);
}
catch (Exception ex)
{
Log.Error("Unable to iniatilize fields for component with ID " + tcmUri + "\r\n Exception: " + ex);
}
break;
case ItemType.Page:
try
{
_page = new Page(tcmUri, engine.GetSession());
_currentItem = _page;
if (_page.Metadata != null)
{
_metadataFields = new ItemFields(_page.Metadata, _page.MetadataSchema);
}
else
{
Log.Error("Only pages with metadata are allowed.");
}
}
catch (Exception ex)
{
Log.Error("Unable to initialize fields for page with ID " + tcmUri + "\r\n Exception: " + ex);
}
break;
case ItemType.Publication:
try
{
_publication = new Publication(tcmUri, engine.GetSession());
_currentItem = null;
if (_publication.Metadata != null)
{
_metadataFields = new ItemFields(_publication.Metadata, _publication.MetadataSchema);
}
else
{
Log.Error("Only Publications with Metadata are supported!");
}
}
catch (Exception ex)
{
Log.Error("Unable to initialize fields for publication with ID " + tcmUri + "\r\n Exception: " + ex);
}
break;
case ItemType.StructureGroup:
try
{
_structureGroup = new StructureGroup(tcmUri, engine.GetSession());
_currentItem = _structureGroup;
if (_structureGroup.Metadata != null)
{
_metadataFields = new ItemFields(_structureGroup.Metadata, _structureGroup.MetadataSchema);
}
else
{
Log.Error("Only Structure Groups with Metadata are supported!");
}
}
catch (Exception ex)
{
Log.Error("Unable to initialize fields for Structure Group with ID " + tcmUri + "\r\n Exception: " + ex);
}
break;
case ItemType.Folder:
try
{
_folder = new Folder(tcmUri, engine.GetSession());
_currentItem = _folder;
if (_folder.Metadata != null)
{
_metadataFields = new ItemFields(_folder.Metadata, _folder.MetadataSchema);
}
else
{
Log.Error("Only Folders with Metadata are supported!");
}
}
catch (Exception ex)
{
Log.Error("Unable to initialize fields for Folder with ID " + tcmUri + "\r\n Exception: " + ex);
}
break;
case ItemType.Category:
try
{
_category = new Category(tcmUri, engine.GetSession());
_currentItem = _category;
if (_category.Metadata != null)
{
_metadataFields = new ItemFields(_category.Metadata, _category.MetadataSchema);
}
else
{
Log.Error("Only Categories with Metadata are supported!");
}
}
catch (Exception ex)
{
Log.Error("Unable to initialize fields for Category with ID " + tcmUri + " \r\n Exception: " + ex);
}
break;
case ItemType.Keyword:
try
{
_keyword = new Keyword(tcmUri, engine.GetSession());
_currentItem = _keyword;
if (_keyword.Metadata != null)
{
_metadataFields = new ItemFields(_keyword.Metadata, _keyword.MetadataSchema);
_escapeOutput = true;
}
else
{
Log.Error("Only Keywords with Metadata are supported!");
}
}
catch (Exception ex)
{
Log.Error("Unable to initialize fields for Keyword with ID " + tcmUri + " \r\n Exception: " + ex);
}
break;
}
_engine = engine;
_package = package;
_itemType = tcmUri.ItemType;
}
}
protected List<KeyValuePair<TcmUri, string>> GetUsingItems(RepositoryLocalObject subject, ItemType itemType)
{
UsingItemsFilter filter = new UsingItemsFilter(Engine.GetSession())
{
ItemTypes = new List<ItemType> { itemType },
BaseColumns = ListBaseColumns.IdAndTitle
};
return XmlElementToTcmUriList(subject.GetListUsingItems(filter));
}
/// <summary>
/// Audits the object unlocalizations
/// </summary>
/// <param name="repositoryObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="args">The <see cref="UnLocalizeEventArgs" /> instance containing the event data.</param>
/// <param name="phase"><see cref="T:Tridion.ContentManager.Extensibility.EventPhases" /></param>
private void AuditUnLocalize(RepositoryLocalObject repositoryObject, UnLocalizeEventArgs args, EventPhases phase)
{
if (phase == EventPhases.TransactionCommitted)
AuditContentEdit("UnLocalize", repositoryObject, null, new SqlXml(repositoryObject.ToXml().CreateNavigator().ReadSubtree()));
}
