/// <summary>
/// Publishes a <see cref="T:Tridion.ContentManager.IdentifiableObject"/> to a given <see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget"/> and
/// with <see cref="T:Tridion.ContentManager.Publishing.PublishPriority"/>
/// </summary>
/// <param name="PublishUser"><see cref="T:Tridion.ContentManager.Security.User"/></param>
/// <param name="Item"><see cref="T:Tridion.ContentManager.IdentifiableObject"/></param>
/// <param name="Target"><see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget"/></param>
/// <param name="Priority"><see cref="T:Tridion.ContentManager.Publishing.PublishPriority"/></param>
/// <param name="startDate"><see cref="T:System.DateTime"/></param>
public void PublishItem(User PublishUser, IdentifiableObject Item, PublicationTarget Target, PublishPriority Priority, DateTime startDate)
{
if (Engine.RenderMode == RenderMode.Publish)
{
if (startDate == null)
{
startDate = DateTime.Now;
}
using (Session session = new Session(PublishUser.Title))
{
PublishInstruction publishInstruction = new PublishInstruction(session)
{
StartAt = startDate,
DeployAt = startDate
};
RenderInstruction renderInstruction = new RenderInstruction(session);
renderInstruction.RenderMode = RenderMode.Publish;
publishInstruction.RenderInstruction = renderInstruction;
PublishEngine.Publish(new IdentifiableObject[] { session.GetObject(Item.Id) }, publishInstruction, new PublicationTarget[] { Target }, Priority);
}
}
}
/// <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>
/// 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>
/// Retrieve the <see cref="T:Tridion.ContentManager.IdentifiableObject" /> published information
/// </summary>
/// <param name="identifiableObject"><see cref="T:Tridion.ContentManager.IdentifiableObject" /></param>
/// <returns><see cref="T:Tridion.ContentManager.Publishing.PublishInfo" /></returns>
public static IEnumerable <PublishInfo> PublishInfo(this IdentifiableObject identifiableObject)
{
if (identifiableObject != null)
{
return(PublishEngine.GetPublishInfo(identifiableObject));
}
return(new PublishInfo[] { });
}
/// <summary>
/// Determines whether item is published in the current publication context.
/// </summary>
/// <param name="identifiableObject">The item <see cref="Tridion.ContentManager.IdentifiableObject"/>.</param>
/// <param name="publicationTarget">The publication target <see cref="Tridion.ContentManager.CommunicationManagement.PublicationTarget"/>.</param>
/// <returns>
/// <c>true</c> if item is published in current publication context, otherwise <c>false</c>.
/// </returns>
public static bool IsPublished(this IdentifiableObject identifiableObject, PublicationTarget publicationTarget)
{
if (identifiableObject != null && publicationTarget != null)
{
return(PublishEngine.IsPublished(identifiableObject, publicationTarget, true));
}
return(false);
}
private bool IsPublished(Page page)
{
if (Engine.PublishingContext.PublicationTarget != null)
{
return(PublishEngine.IsPublished(page, Engine.PublishingContext.PublicationTarget));
}
//For preview we always return true - to help debugging
return(true);
}
private static DateTime?GetPublishedDate(Page page, TargetType targetType)
{
PublishInfo publishInfo = PublishEngine.GetPublishInfo(page).FirstOrDefault(pi => pi.TargetType == targetType);
if (publishInfo == null)
{
return(null);
}
return(publishInfo.PublishedAt);
}
private static string GetPublishedDate(Page page, PublicationTarget target)
{
ICollection <PublishInfo> publishInfos = PublishEngine.GetPublishInfo(page);
foreach (PublishInfo publishInfo in publishInfos)
{
if (publishInfo.PublicationTarget == target)
{
return(publishInfo.PublishedAt.GetIso8601Date());
}
}
return("");
}
private void PublishTest()
{
var targets = ContentDeliveryTargetUtil.GetSiteSettings("http://local.cds.com/cdsapi/v1/settings/getsettings", "{9FFE62F6-FAE2-46E3-A6E9-2D1B4604767A}");
if (targets != null && targets.Any())
{
var intSettings = targets.FirstOrDefault(x => x.Code.Equals("INT", StringComparison.InvariantCultureIgnoreCase));
if (intSettings != null)
{
PublishEngineContext publishEngineContext = new PublishEngineContext();
publishEngineContext.PublishTargetSettings = intSettings;
PublishEngine publishEngine = new PublishEngine();
var results = publishEngine.Publish(publishEngineContext);
richTextBox1.AppendText(string.Format("MainContentTempFolder:{0}\n", publishEngineContext.Results.MainContentTempFolder));
richTextBox1.AppendText(string.Format("MainContentCloned:{0}\n", publishEngineContext.Results.MainContentCloned));
richTextBox1.AppendText(string.Format("JsonFilesTempFolder:{0}\n", publishEngineContext.Results.JsonFilesTempFolder));
richTextBox1.AppendText(string.Format("JsonFilesDownloaded:{0}\n", publishEngineContext.Results.JsonFilesDownloaded));
richTextBox1.AppendText(string.Format("MergeSecondaryAndMaster:{0}\n", publishEngineContext.PublishTargetSettings.GitHubSettings.MergeSecondaryAndMaster));
richTextBox1.AppendText(string.Format("SecondaryContentTempFolder:{0}\n", publishEngineContext.Results.SecondaryContentTempFolder));
richTextBox1.AppendText(string.Format("SecondaryContentCloned:{0}\n", publishEngineContext.Results.SecondaryContentCloned));
richTextBox1.AppendText(string.Format("CiContentTempFolder:{0}\n", publishEngineContext.Results.CiContentTempFolder));
richTextBox1.AppendText(string.Format("CiContentCloned:{0}\n", publishEngineContext.Results.CiContentCloned));
richTextBox1.AppendText(string.Format("IsAbort:{0}\n", publishEngineContext.Results.IsAbort));
richTextBox1.AppendText(string.Format("IsFinished:{0}\n", publishEngineContext.Results.IsFinished));
richTextBox1.AppendText(string.Format("ErrorMessage:{0}\n\n", publishEngineContext.Results.ErrorMessage));
foreach (var eventItem in publishEngineContext.MessageLogger.GetEvents())
{
var typeExample = new { EntryDate = eventItem.TimeStamp.ToLongDateString(), Level = eventItem.Level.Name, Message = eventItem.MessageObject };
JObject o = JObject.FromObject(typeExample);
string json = o.ToString();
richTextBox1.AppendText(string.Format("{0}\n\n", json));
}
}
}
}
/// <summary>
/// Retrieve the <see cref="T:Tridion.ContentManager.IdentifiableObject" /> published information
/// </summary>
/// <param name="identifiableObject"><see cref="T:Tridion.ContentManager.IdentifiableObject" /></param>
/// <param name="publicationTarget">Publication target <see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget"/> to filter on.</param>
/// <returns>
/// <see cref="T:Tridion.ContentManager.Publishing.PublishInfo" />
/// </returns>
public static IEnumerable <PublishInfo> PublishInfo(this IdentifiableObject identifiableObject, PublicationTarget publicationTarget)
{
if (identifiableObject != null && publicationTarget != null)
{
ICollection <PublishInfo> publishInfos = PublishEngine.GetPublishInfo(identifiableObject);
if (publishInfos != null && publishInfos.Count > 0)
{
return(publishInfos.Where(x => x.PublicationTarget.Id == publicationTarget.Id));
}
}
return(new PublishInfo[] { });
}
/// <summary>
/// Publishes an <see cref="T:Tridion.ContentManager.IdentifiableObject" /> intelligently if and only if, <see cref="T:Tridion.ContentManager.IdentifiableObject" /> is not in
/// "Waiting For Publish" state or "Scheduled For Publish" state within the scheduleDateFilter <see cref="T:System.DateTime" />
/// </summary>
/// <param name="identifiableObject">The <see cref="T:Tridion.ContentManager.IdentifiableObject" />.</param>
/// <param name="startDateFilter">The start <see cref="T:System.DateTime"/> filter.</param>
/// <param name="scheduleDateFilter">The schedule <see cref="T:System.DateTime"/> filter.</param>
/// <param name="publishStartDate">The publish start <see cref="T:System.DateTime"/>.</param>
public void PublishIntelligently(IdentifiableObject identifiableObject, DateTime startDateFilter, DateTime scheduleDateFilter, DateTime publishStartDate)
{
PublishTransactionsFilter filter = new PublishTransactionsFilter(Engine.GetSession())
{
StartDate = startDateFilter,
PublicationTarget = PublicationTarget,
ForRepository = GetObject <Repository>(Publication.Id)
};
PublishTransaction publishTransaction = PublishEngine.GetPublishTransactions(filter)
.FirstOrDefault(t => t.Items.Count > 0 &&
t.Items.First().Id == identifiableObject.Id &&
(t.State == PublishTransactionState.WaitingForPublish ||
(t.State == PublishTransactionState.ScheduledForPublish && scheduleDateFilter >= t.Instruction.StartAt)));
if (publishTransaction == null)
{
PublishItem(identifiableObject, publishStartDate);
}
}
private bool IsPublished(Page page)
{
//For preview we always return true - to help debugging
return((Engine.PublishingContext?.PublicationTarget == null) || PublishEngine.IsPublished(page, Engine.PublishingContext.PublicationTarget));
}
/// <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>
/// Publish Event handler which is triggered on publishing (or unpublishing) any repository local object. The handler
/// will publish the item if published in a source publication to any publications defined as target publications.
/// </summary>
/// <param name="publishedItem">Item being published (page, component, category etc)</param>
/// <param name="args">Publishing or unpublishing arguments</param>
/// <param name="phase">event phase for the transaction</param>
private void PublishEvent(RepositoryLocalObject publishedItem, PublishOrUnPublishEventArgs args, EventPhases phase)
{
var publication = publishedItem.ContextRepository as Publication;
// Make sure the publication is in the list of publications where publishing should be mirrored
if (Settings.SOURCE_PUBS.Any(p => p.Equals(publication?.Title) || p.Equals(publication?.Id)))
{
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug("Publication title is in the list of source publications.");
var publishStatus = args is PublishEventArgs ? "Publish" : "Unpublish";
var publishEvent = args is PublishEventArgs ? args as PublishEventArgs : null;
var unpublishEvent = args is UnPublishEventArgs ? args as UnPublishEventArgs : null;
var creator = publishEvent != null?
publishEvent.PublishTransactions?.FirstOrDefault()?.Creator:
unpublishEvent?.PublishTransactions?.FirstOrDefault()?.Creator;
logger.Info(
$"{publishStatus} event " +
$"[initiated by]: {creator.Title} ({creator.Id}) -- " +
$"[publishing targets]: {args.Targets.Select(t => $"{t.Title} ({t.Id})")?.PrintList()} -- " +
$"[original publish item]: {publishedItem.Id} ({publishedItem.Title}) -- " +
$"[all {publishStatus} items (also published)]: {args.Items.Select(i => $"{i.Title} ({i.Id})")?.PrintList()}."
);
}
// Get the instruction & figure out if its a publish or an unpublish
var publishUnpublishInstruction = TridionUtil.GetPublishOrUnpublishInstruction(args);
// Get the publications for which publishing should be mirrored
var mirrorPublications = TridionUtil.GetPublications(Settings.TARGET_PUBS, publishedItem.Session);
if (mirrorPublications == null || mirrorPublications.Count < 1)
{
logger.Debug("No mirror publications found."); return;
}
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug($"Found the list of mirror publications : {mirrorPublications.Select(p => p.Title + ", ")?.PrintList()} .");
}
// Get the item which needs to be published in the mirrored publication
var mirrorItems = TridionUtil.GetItemsInPublications(publishedItem, mirrorPublications?.Select(p => p.Id)?.ToList(), publishedItem.Session);
if (mirrorItems == null || mirrorItems.Count < 1)
{
logger.Debug("No mirror items found."); return;
}
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug($"Mirroring {mirrorItems.Count} publish items : {mirrorItems.Select(i => i.Id + ", ")?.PrintList()}.");
}
try
{
// Publish the items to be mirrored in the mirrored publications
if (args.Targets.Count() > 0 && mirrorItems.Count() > 0 && mirrorPublications.Count() > 0)
{
var publishedItemIds = mirrorItems.Select(p => p.Id.ToString())?.PrintList();
var publicationTitles = mirrorPublications.Select(p => p.Title)?.PrintList();
var publishingTargetIds = args.Targets.Select(t => t.Id.ToString())?.PrintList();
var targetTypes = args.Targets.Select(t => t as TargetType);
if (targetTypes == null || targetTypes.Count() < 1)
{
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug("No target types found. Returning.");
}
return;
}
if (args is PublishEventArgs)
{
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug("Publishing event being mirrored.");
}
var publishInstruction = (PublishInstruction)publishUnpublishInstruction;
if (Settings.FORCE_PUBLISH_CHILD_PUBS)
{
publishInstruction.ResolveInstruction.IncludeChildPublications = true;
}
if (Settings.FORCE_PUBLISH_MINOR_VERSION)
{
publishInstruction.ResolveInstruction.IncludeDynamicVersion = true;
}
if (Settings.FORCE_PUBLISH_WORKFLOW_VERSION)
{
publishInstruction.ResolveInstruction.IncludeWorkflow = true;
}
// if the setting is selected to mirror the transaction only if publish to children is selected, but the setting is false, exit.
if (Settings.MIRROR_IF_PROPOGATE_SELECTED && !publishInstruction.ResolveInstruction.IncludeChildPublications)
{
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug("Exiting as mirror if propogate selected, but setting is false.");
}
return;
}
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Info($"Mirroring publishing items '{publishedItemIds}' -- to publications {publicationTitles} -- to targets {targetTypes.Select(t => t.Title)?.PrintList()}.");
}
PublishEngine.Publish(mirrorItems, publishInstruction, targetTypes, PublishPriority.Low);
}
else if (args is UnPublishEventArgs)
{
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug("Unpublishing event being mirrored.");
}
var unpublishInstruction = (UnPublishInstruction)publishUnpublishInstruction;
if (Settings.FORCE_PUBLISH_CHILD_PUBS)
{
unpublishInstruction.ResolveInstruction.IncludeChildPublications = true;
}
// if the setting is selected to mirror the transaction only if publish to children is selected, but the setting is false, exit.
if (Settings.MIRROR_IF_PROPOGATE_SELECTED && !unpublishInstruction.ResolveInstruction.IncludeChildPublications)
{
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Debug("Exiting as mirror if propogate selected, but setting is false.");
}
return;
}
if (Settings.PUBLISH_LOGGING_ENABLED)
{
logger.Info($"Mirroring unpublishing items '{publishedItemIds}' -- to publications {publicationTitles} -- to targets {publishingTargetIds}.");
}
PublishEngine.UnPublish(mirrorItems, unpublishInstruction, targetTypes, PublishPriority.Low);
}
}
}
catch (Exception ex)
{
logger.Error($"Error publishing items : {ex.Message} {ex.ToString()} {ex.StackTrace}");
}
}
}