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