/// <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>
/// 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 CurrentMode GetCurrentMode()
{
RenderMode renderMode = _engine.RenderMode;
if (renderMode == RenderMode.Publish)
{
return(CurrentMode.Publish);
}
if (renderMode == RenderMode.PreviewDynamic)
{
if (_engine.PublishingContext.PublicationTarget == null)
{
return(CurrentMode.TemplateBuilder);
}
PublicationTarget target = _engine.PublishingContext.PublicationTarget;
if (target.Id.Equals(TcmUri.UriNull))
{
return(CurrentMode.CmePreview);
}
return(CurrentMode.SessionPreview);
}
return(CurrentMode.Unknown);
}
public static bool IsSiteEditEnabled(this PublicationTarget target)
{
try
{
if (target == null)
{
return(true);
}
ApplicationData appData = target.LoadApplicationData("SiteEdit");
string data = Encoding.UTF8.GetString(appData.Data);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(data);
XmlNamespaceManager nsManager = new XmlNamespaceManager(new NameTable());
nsManager.AddNamespace("se", "http://www.sdltridion.com/2011/SiteEdit");
XmlNode seNode = xmlDoc.SelectSingleNode("/se:configuration/se:PublicationTarget/se:EnableSiteEdit",
nsManager);
if (seNode != null && seNode.InnerText.Equals("true"))
{
return(true);
}
return(false);
}
catch (Exception)
{
//AAngel: Quick fix to make the pages publishable to live, probably can be done better. They were failing when the target is not Site Edit enabled
return(false);
}
}
/// <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);
}
public static bool IsSiteEditEnabled(this PublicationTarget target)
{
try
{
if (target == null)
{
return(true);
}
ApplicationData appData = target.LoadApplicationData("SiteEdit");
string data = Encoding.UTF8.GetString(appData.Data);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(data);
XmlNamespaceManager nsManager = new XmlNamespaceManager(new NameTable());
nsManager.AddNamespace("se", "http://www.sdltridion.com/2011/SiteEdit");
XmlNode seNode = xmlDoc.SelectSingleNode("/se:configuration/se:PublicationTarget/se:EnableSiteEdit",
nsManager);
if (seNode != null && seNode.InnerText.Equals("true"))
{
return(true);
}
return(false);
}
catch (Exception)
{
// Quick and dirty fix
return(false);
}
}
/// <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>
/// 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);
}
/// <summary>
/// Execute the transformation for the specified template
/// </summary>
/// <param name="Engine"><see cref="T:Tridion.ContentManager.Templating.Engine"/>.</param>
/// <param name="Package"><see cref="T:Tridion.ContentManager.Templating.Package"/></param>
public void Transform(Engine Engine, Package Package)
{
try
{
mTicksStart = Environment.TickCount;
mEngine = Engine;
mPackage = Package;
// Actual template transformation
PreTransform();
Transform();
PostTransform();
}
catch (Exception ex)
{
String exceptionStack = LoggerExtensions.TraceException(ex);
Logger.Error("TemplateBase.Transform Exception\n" + exceptionStack);
StringBuilder sb = new StringBuilder();
sb.AppendLine(ex.Message);
sb.AppendFormat("Publisher: {0}\n", Environment.MachineName);
sb.Append(exceptionStack);
// Re-throw to ensure Tridion knows what happened
throw new Exception(sb.ToString(), ex);
}
// Ensure we always clean up, no matter what happens during the template transformation
finally
{
Logger.Info("{0}: Render time {1:0.00000} seconds @ {2:dd/MM/yyyy hh:mm:ss tt} ", this.GetType().FullName, ProcessedTime / 1000.0, DateTime.Now);
// Do not cache objects across template transformations
ItemFieldsFactory.ClearCache();
// Clear published binaries list if it was used
if (mPublishedBinaries.IsValueCreated)
{
mPublishedBinaries.Value.Clear();
}
mPackage = null;
mEngine = null;
mLogger = null;
mComponent = null;
mComponentTemplate = null;
mPage = null;
mPageTemplate = null;
mRootStructureGroup = null;
mPublication = null;
mPublishTransaction = null;
mPublishingUser = null;
mPublicationTarget = null;
}
}
/// <summary>
/// Gets the approved version of the item being rendered for the current target.
/// </summary>
/// <param name="item">The item in question.</param>
/// <param name="target">The target you're publishing to.</param>
/// <returns>Either the same version or a later version if in workflow and its approval status is high enough for this target</returns>
private VersionedItem GetApprovedVersionForTarget(VersionedItem item, PublicationTarget target)
{
bool isPreview = false;
if (!item.LockType.HasFlag(LockType.InWorkflow))
{
return(item);
}
if (target == null)
{
isPreview = true;
}
if (!isPreview && target.Id == TcmUri.UriNull)
{
isPreview = true;
}
if (item is Page)
{
Page pageInWorkflow =
(Page)_engine.GetObject(new TcmUri(item.Id.ItemId, item.Id.ItemType, item.Id.PublicationId, 0));
if (isPreview)
{
return(pageInWorkflow);
}
int targetApprovalStatus;
if (target.MinApprovalStatus == null)
{
targetApprovalStatus = 0;
}
else
{
targetApprovalStatus = target.MinApprovalStatus.Position;
}
return(pageInWorkflow.ApprovalStatus.Position >= targetApprovalStatus
? pageInWorkflow
: item);
}
if (item is Component)
{
Component componentInWorkflow =
(Component)_engine.GetObject(new TcmUri(item.Id.ItemId, item.Id.ItemType, item.Id.PublicationId, 0));
if (isPreview)
{
return(componentInWorkflow);
}
return(componentInWorkflow.ApprovalStatus.Position >= target.MinApprovalStatus.Position
? componentInWorkflow
: item);
}
return(item);
}
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("");
}
public static bool IsPublicationTargetXpmEnabled(PublicationTarget publicationTarget)
{
ApplicationData appData = publicationTarget?.LoadApplicationData(SiteEditApplicationId);
if (appData == null)
{
return(false);
}
ApplicationDataAdapter ada = new ApplicationDataAdapter(appData);
XmlElement appDataXml = ada.GetAs <XmlElement>();
return(appDataXml?.SelectSingleNode("self::se:configuration/se:PublicationTarget[se:EnableSiteEdit = 'true']", GetSeNamespaceManager()) != null);
}
public void Transform(Engine engine, Package package)
{
if (engine.PublishingContext.PublicationTarget == null)
{
// Template Builder
SetValue(package, false);
return;
}
PublicationTarget target = engine.PublishingContext.PublicationTarget;
if (target.Id == TcmUri.UriNull)
{
// Content Manager Preview, we might need markup since this may be UI's Update Preview
SetValue(package, true);
return;
}
if (target.LoadApplicationData("SiteEdit") == null)
{
// No App Data for this target, no SiteEdit
SetValue(package, false);
return;
}
ApplicationData appData = target.LoadApplicationData("SiteEdit");
string data = Encoding.UTF8.GetString(appData.Data);
XmlDocument seConfig = new XmlDocument();
seConfig.LoadXml(data);
XmlNamespaceManager nsManager = new XmlNamespaceManager(new NameTable());
nsManager.AddNamespace("se", "http://www.sdltridion.com/2011/SiteEdit");
XmlNode seNode = seConfig.SelectSingleNode("/se:configuration/se:PublicationTarget/se:EnableSiteEdit", nsManager);
if (seNode != null && seNode.InnerText.Equals("true"))
{
SetValue(package, true);
return;
}
SetValue(package, false);
}
public static bool IsPublicationTargetXpmEnabled(PublicationTarget publicationTarget)
{
bool enabled = false;
if (publicationTarget != null)
{
ApplicationData appData = publicationTarget.LoadApplicationData(SiteEditApplicationId);
if (appData != null)
{
ApplicationDataAdapter ada = new ApplicationDataAdapter(appData);
XmlElement appDataXml = ada.GetAs<XmlElement>();
if (appDataXml != null)
{
if (appDataXml.SelectSingleNode("self::se:configuration/se:PublicationTarget[se:EnableSiteEdit = 'true']", GetSeNamespaceManager()) != null)
{
enabled = true;
}
}
}
}
return enabled;
}
public void Transform(Engine engine, Package package)
{
_log = TemplatingLogger.GetLogger(GetType());
_engine = engine;
string itemName = string.Empty;
if (package.GetByName(Package.ComponentName) != null)
{
itemName = Package.ComponentName;
}
if (package.GetByName(Package.PageName) != null)
{
itemName = Package.PageName;
}
if (string.IsNullOrEmpty(itemName))
{
_log.Debug("Could not determine template type, exiting");
return;
}
VersionedItem item = (VersionedItem)engine.GetObject(package.GetByName(itemName));
if (item.LockType.HasFlag(LockType.InWorkflow))
{
CurrentMode mode = GetCurrentMode();
VersionedItem w = item.GetVersion(0);
switch (mode)
{
case CurrentMode.CmePreview:
case CurrentMode.TemplateBuilder:
case CurrentMode.SessionPreview:
// return workflow object without comparing to Publication Target Minimum Approval Status
package.Remove(package.GetByName(itemName));
if (itemName.Equals(Package.ComponentName))
{
package.PushItem(Package.ComponentName, package.CreateTridionItem(ContentType.Component, w));
}
else if (itemName.Equals(Package.PageName))
{
package.PushItem(Package.PageName, package.CreateTridionItem(ContentType.Page, w));
}
break;
case CurrentMode.Publish:
PublicationTarget target = _engine.PublishingContext.PublicationTarget;
ApprovalStatus targetStatus = target.MinApprovalStatus;
ApprovalStatus contentStatus = null;
if (w is Component)
{
contentStatus = ((Component)w).ApprovalStatus;
}
else if (w is Page)
{
contentStatus = ((Page)w).ApprovalStatus;
}
if (contentStatus == null)
{
_log.Debug("Could not determine approval status of content. Exiting.");
return;
}
bool mustUpdate = false;
if (targetStatus == null)
{
mustUpdate = true;
}
else
{
if (contentStatus.Position > targetStatus.Position)
{
mustUpdate = true;
}
}
if (mustUpdate)
{
package.Remove(package.GetByName(itemName));
if (itemName.Equals(Package.ComponentName))
{
package.PushItem(Package.ComponentName, package.CreateTridionItem(ContentType.Component, w));
}
else if (itemName.Equals(Package.PageName))
{
package.PushItem(Package.PageName, package.CreateTridionItem(ContentType.Page, w));
}
}
break;
}
}
}
/// <summary>
/// Gets the approved version of the item being rendered for the current target.
/// </summary>
/// <param name="item">The item in question.</param>
/// <param name="target">The target you're publishing to.</param>
/// <returns>Either the same version or a later version if in workflow and its approval status is high enough for this target</returns>
private VersionedItem GetApprovedVersionForTarget(VersionedItem item, PublicationTarget target)
{
bool isPreview = false;
if (!item.LockType.HasFlag(LockType.InWorkflow))
return item;
if (target == null)
{
isPreview = true;
}
if (!isPreview && target.Id == TcmUri.UriNull)
{
isPreview = true;
}
if (item is Page)
{
Page pageInWorkflow =
(Page)_engine.GetObject(new TcmUri(item.Id.ItemId, item.Id.ItemType, item.Id.PublicationId, 0));
if (isPreview) return pageInWorkflow;
int targetApprovalStatus;
if (target.MinApprovalStatus == null)
targetApprovalStatus = 0;
else
targetApprovalStatus = target.MinApprovalStatus.Position;
return pageInWorkflow.ApprovalStatus.Position >= targetApprovalStatus
? pageInWorkflow
: item;
}
if (item is Component)
{
Component componentInWorkflow =
(Component)_engine.GetObject(new TcmUri(item.Id.ItemId, item.Id.ItemType, item.Id.PublicationId, 0));
if (isPreview) return componentInWorkflow;
return componentInWorkflow.ApprovalStatus.Position >= target.MinApprovalStatus.Position
? componentInWorkflow
: item;
}
return item;
}
/// <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>
public void PublishItem(User PublishUser, IdentifiableObject Item, PublicationTarget Target, PublishPriority Priority)
{
PublishItem(PublishingUser, Item, Engine.PublishingContext.PublicationTarget, PublishTransaction.Priority, DateTime.Now);
}
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 "";
}
/// <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;
}
/// <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>
/// Returns the last publish date in the given <see cref="T:Tridion.ContentManager.CommunicationManagement.Publication" /> and
/// given <see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget" />
/// </summary>
/// <param name="identifiableObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="publication"><see cref="T:Tridion.ContentManager.CommunicationManagement.Publication" /></param>
/// <param name="publicationTarget"><see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget" /></param>
/// <returns>
/// Returns <see cref="T:System.DateTime" /> or DateTime.MinValue
/// </returns>
public static DateTime PublishedAt(this IdentifiableObject identifiableObject, Publication publication, PublicationTarget publicationTarget)
{
if (identifiableObject != null && publication != null && publicationTarget != null)
{
PublishInfo info = identifiableObject.PublishInfo(publication, publicationTarget).FirstOrDefault();
if (info != null)
return info.PublishedAt;
}
return default(DateTime);
}
/// <summary>
/// Returns the last publish date in the given <see cref="T:Tridion.ContentManager.CommunicationManagement.Publication" /> and
/// given <see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget" />
/// </summary>
/// <param name="identifiableObject"><see cref="T:Tridion.ContentManager.ContentManagement.RepositoryLocalObject" /></param>
/// <param name="publication"><see cref="T:Tridion.ContentManager.CommunicationManagement.Publication" /></param>
/// <param name="publicationTarget"><see cref="T:Tridion.ContentManager.CommunicationManagement.PublicationTarget" /></param>
/// <returns>
/// Returns <see cref="T:System.DateTime" /> or DateTime.MinValue
/// </returns>
public static DateTime PublishedAt(this IdentifiableObject identifiableObject, Publication publication, PublicationTarget publicationTarget)
{
if (identifiableObject != null && publication != null && publicationTarget != null)
{
PublishInfo info = identifiableObject.PublishInfo(publication, publicationTarget).FirstOrDefault();
if (info != null)
{
return(info.PublishedAt);
}
}
return(default(DateTime));
}
/// <summary>
/// Retrieve the <see cref="T:Tridion.ContentManager.IdentifiableObject" /> published information
/// </summary>
/// <param name="Object"><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, Publication publication, PublicationTarget publicationTarget)
{
if (identifiableObject != null && publication != null && publicationTarget != null)
{
ICollection<PublishInfo> publishInfos = PublishEngine.GetPublishInfo(identifiableObject);
if (publishInfos != null && publishInfos.Count > 0)
return publishInfos.Where(x => x.Publication.Id == publication.Id && x.PublicationTarget.Id == publicationTarget.Id);
}
return null;
}
