Is there a pipeline I can add to and/or event to intercept that would allow me to set the lock on an item only if a lock in the foreign system is possible? [Mainly interested with this functionality in the Media Library]
We are currently looking to provide syncing functionality with Sitecore items and I'm running through a checklist of use cases to determine feasibility. Locking an item currently needs to lock an item in the foreign system.
I read John West's blog post explaining the interception of Item Updates.
If you need to be able to block the save operation, consider the saveUI pipeline, the item:saving event, or field validators. If you need to prevent the visual effect in the user interface that indicates that Sitecore has saved the selected item, consider the saveUI pipeline or field validators.
This is useful to me later when I need to possibly block the saving of an item because of an error in the foreign system, but it does not state anything as the locking/editing begins.
I also noted on John's Important Pipelines blog post that there is no "uiEditItem" or anything that seems to note a pipeline with item editing.
You could propably place your own processor before "Sitecore.Pipelines.Save.CheckItemLock" in the saveUI section.
In your processor you can abort the saving of an item by calling the AbortPipeline method.
If you want to check if the saved item gets locked, you can check if the lock field has changed.
Here is some example code:
public class CheckForeignLock {
protected bool UserIsTryingToLockItem(SaveArgs args) {
var lockfield = args.Fields.SingleOrDefault(x => x.ID == FieldIDs.Lock);
return lockfield != null && lockfield.OriginalValue != lockfield.Value;
}
protected bool CanLock() {
// your code
}
public void Process(SaveArgs args) {
if(UserIsTryingToLockItem(args) && !CanLock()) {
args.AbortPipeline();
}
}
}
And here the place where you could register your processor:
<processor mode="on" type="Sitecore.Pipelines.Save.ParseXml, Sitecore.Kernel" />
<processor mode="on" type="YourAssembly.CheckForeignLock, YourAssembly" />
<processor mode="on" type="Sitecore.Pipelines.Save.CheckItemLock, Sitecore.Kernel" />
Related
I have a rich text field that has certain tokens ({{alt}} and {{title}}) for embedded images in the HTML. I extended the Sitecore.Pipelines.RenderField.GetFieldValue processor so that when a page is rendered on the front end, the processor will replace those tokens with the alt and title field values from the media item. Unfortunately my custom processor only processes a certain set of items (specifically WFFM fields), it does not process my Body field which has the tokens, even though I know the page I am browsing is rendering that field (the code run on the layout is #Html.Sitecore().Field("Body") which means it should get processed by the pipeline, correct?)
I also tried the GetTextFieldValue and GetMemoFieldValue processors but the same items were processed. Looking for some guidance as to specifically which fields are supposed to get processed by this pipeline.
Here is my Process() function:
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
Assert.ArgumentNotNull(args.Item, "args.Item");
Assert.ArgumentNotNull(args.GetField(), "args.GetField()");
if (args.Item.Database == Database.GetDatabase("web"))
{
if (args.GetField().Value.Contains("{{alt}}"))
{
args.GetField().Value = ReplaceAltToken(args.GetField().Value);
}
if (args.GetField().Value.Contains("{{title}}"))
{
args.GetField().Value = ReplaceTitleToken(args.GetField().Value);
}
if (args.GetField().Name == "Body")
{
// Since we're rendering the body field differently we need to expand dynamic links
args.Item.Editing.BeginEdit();
args.GetField().Value = Sitecore.Links.LinkManager.ExpandDynamicLinks(args.GetField().Value);
args.Item.Editing.EndEdit();
}
}
}
My config include file:
<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
<sitecore>
<pipelines>
<renderField>
<processor
type="[Redacted].Processor.RenderField.GetFieldValueExtended, [Redacted].Processor"
patch:after="processor[#type='Sitecore.Pipelines.RenderField.GetFieldValue, Sitecore.Kernel']" />
</renderField>
</pipelines>
</sitecore>
There were multiple steps to resolving this issue. Unchecking Cacheable on all renderings was an important first step. The rest of the issues I encountered were most likely specific to my solution (not well designed and will be refactored soon).
My local site did not have the most up to date files. When I updated the files, I still ran into the Attempt to retrieve context object of type 'Sitecore.Mvc.Presentation.PageContext' from empty stack error, which I was able to workaround by calling Sitecore.Web.UI.WebControls.FieldRenderer.Render(item, "Body") in a simple GetBody() function in the model, instead of Html.Sitecore().Field("Body"). Then in the view I simply put #Html.Raw(Model.Body).
I think the .Field() helper did not work because the item associated with the field requested was unknown, so yet another workaround is using Html.Sitecore().Field("Body", item) which specifies the item directly in the parameters.
I have a custom pipeline processor inserted after ItemResolver in which I overwrite the current context item with a new item selected by the content editor from a droplink.
If I go to that dynamic item via a normal request through my website and through my processor and i change my context item, it will stil render the same item:
public override void Process(HttpRequestArgs args)
{
// some code
Context.Item = dropLink.TargetItem;
}
Strangely, if I issue a request via the item API, sitecore changes the item successfully
//api call
Context.Item = Context.Database.SelectSingleItem("fast:/sitecore/content/mysite/dynamicitem");
Here is my config file:
<pipelines>
<httpRequestBegin>
<processor patch:after="* #type='Sitecore.Pipelines.HttpRequest.ItemResolver, Sitecore.Kernel']" type="MyDll.Web.Pipelines.LandingPageResolver,MyDll.Web" />
</httpRequestBegin>
</pipelines>
Since you are using MVC the item is resolved (again) using a different set of pipelines, so you need to patch into there instead.
The GetFromRouteUrl processor in the mvc.getPageItem pipeline sets args.Result to the item matching the requested URL which is then eventually set to Context.Item, so it essentially resets the item back to the "correct" item based on the URL and that overwrites the changes you made earlier.
You need to add a need processor to the mvc.getPageItem with some logic to check if the context item has already been resolved.
Update your code in the ItemResolver and store a boolean to indicate that you have already resolved using custom logic, this saves having to run the resolving logic twice:
public override void Process(HttpRequestArgs args)
{
// some code
Context.Item = dropLink.TargetItem;
Context.Items["custom::ItemResolved"] = true;
}
Create a new Class that checks if your custom logic has already resolved the item:
public class CheckItemResolved: GetPageItemProcessor
{
public override void Process(GetPageItemArgs args)
{
if (args.Result == null)
{
var resolved = Sitecore.Context.Items["custom::ItemResolved"];
if (MainUtil.GetBool(resolved, false))
{
// item has previously been resolved
args.Result = Sitecore.Context.Item;
}
}
return;
}
}
And then patch this in:
<pipelines>
<mvc.getPageItem>
<processor type="MyProject.Custom.Pipelines.CheckItemResolved, MyProject.Custom"
patch:before="*[#type='Sitecore.Mvc.Pipelines.Response.GetPageItem.GetFromRouteUrl, Sitecore.Mvc']" />
</mvc.getPageItem>
</pipelines>
The pipeline immediately after is GetFromFromUrl() which would normally set args.Result by re-resolving the Item. By setting it back to Context.Item that processor will break out early and leave your previous logic alone.
You can find more details about MVC and Pipelines in the documentation.
I have a need to update a date time field in Sitecore just before the item is published. This will act like a "publish date time" when the item is actually published. I have successfully implemented this in the workflow and that works fine for items in the workflow by adding a custom action.
For items not in workflow and that should be picked up by the Publish agent, I tapped into the pipeline and added a processor just before the PerformAction processor. The field gets updated fine in the master database but it's never published by the publish agent to the web database. The item with all other values before the field update goes through fine.
I have tried to debug the issue and feel like it's happening because the updated item is not reflected as part of the publishqueue. Is there a way I can force the update of the date time field also published in the same process instead of having to force it to publish?
Any suggestions are welcome.
You are right updated item is not part of the publish queue. You need to put your code into publish:itemProcessing event.
You need to follow next steps:
Add a handler class into
<event name="publish:itemProcessing" help="Receives an argument of type ItemProcessingEventArgs (namespace: Sitecore.Publishing.Pipelines.PublishItem)"/>
Your publish:itemProcessing event will look like
<event name="publish:itemProcessing" help="Receives an argument of type ItemProcessingEventArgs (namespace: Sitecore.Publishing.Pipelines.PublishItem)">
<handler type="YourNameSpace.SetPublishDate, YourAssembly" method="UpdatePublishingDate"/>
</event>
Create your own class for processing items on publish:
public class SetPublishDate
{
/// <summary>
/// Gets from date.
/// </summary>
/// <value>From date.</value>
public DateTime FromDate { get; set; }
/// <summary>
/// Gets to date.
/// </summary>
/// <value>To date.</value>
public DateTime ToDate { get; set; }
public void UpdatePublishingDate(object sender, EventArgs args)
{
var arguments = args as Sitecore.Publishing.Pipelines.PublishItem.ItemProcessingEventArgs;
var db = Sitecore.Configuration.Factory.GetDatabase("master");
Item item = db.GetItem(arguments.Context.ItemId);
if (item != null)
{
using (new Sitecore.Data.Events.EventDisabler())
{
using (new EditContext(item))
{
//PublishDateFieldName must be datetime field
item["PublishDateFieldName"] = DateTime.Now;
}
}
}
}
Depending on what you're going to use this date for, perhaps a slight different approach might be better. The previous answer is valid and will probably work just fine. But updating the master database on publish, may let the publishing engine think that the master item has changed and needs re-publishing. (EventDisabler etc will prevent this, as well as trigger a re-index and so on... Things may get very tricky)
Alternatively, you can write the publish date on the item in the web database instead.
<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
<sitecore>
<pipelines>
<publishItem>
<processor type="Sitecore.Publishing.Pipelines.PublishItem.PerformAction, Sitecore.Kernel">
<patch:attribute name="type">Your.Namespace.PerformAction, Your.Assembly</patch:attribute>
</processor>
</publishItem>
</pipelines>
</sitecore>
</configuration>
And an implementation similar to this:
public class PerformAction : Sitecore.Publishing.Pipelines.PublishItem.PerformAction
{
public override void Process(PublishItemContext context)
{
base.Process(context);
if (context.Aborted || context.VersionToPublish == null || context.VersionToPublish.Source == null)
return;
var target = context.PublishOptions.TargetDatabase.GetItem(context.VersionToPublish.ID, context.VersionToPublish.Language);
if (target == null)
return;
using (new EditContext(target, false /*updateStatistics*/, true /*silent*/))
{
DateField lastPublished = target.Fields["LastPublished"]
lastPublished.Value = Sitecore.DateUtil.IsoNo;
}
}
}
John West have a blog post about this here:
http://www.sitecore.net/learn/blogs/technical-blogs/john-west-sitecore-blog/posts/2011/08/intercept-item-publishing-with-the-sitecore-aspnet-cms.aspx
Having the publish date stored in the web database, you can either read it from there instead, or create a computed index field for the master db, containing the date from the web db instead.
This can perhaps be a more robust solution, but again, it depends on what you're using the field for and if you're in control of the code reading the value.
I have seen how we can provide default conditions and default actions to newly created bucket items. I also know that we can create a custom rule for building path based on custom date field.
But, how can we set the item path when the date field is and the is saved.
Consider an example. We have a bucket item template say "News" which has a date field say "Release Date". We have the settings where on item creation, the item path has the creation date like "/News/2015/09/16/item1". Now, we need to have some logic where we can change the path when the "release date" of "item1" is updated and the item is Saved.
How can we update the item path when item's release date is updated and item is Saved !! do i need to implement some logic in OnItemSaved() method ?
I already went through posts on GeekHive
The simplest way to do this would be to hook into the item:saved event and sync the bucket in there. The following code is untested:
public class ItemSavedEventHandler
{
public void Execute(object sender, ItemSavedEventArgs args)
{
Assert.IsNotNull(sender, "sender is null");
Assert.IsNotNull(args, "args is null");
// WARNING: using the events disabler is not recommended in this case.
// If you do this, the path of the item in question will not be updated and will cause issues when you edit the page and try to specify rendering data sources (the locations won't resolve)
using (new EventsDisabler())
{
var parameter = args.Item;
if (!BucketManager.IsItemContainedWithinBucket(paremeter))
{
return;
}
var bucketItem = parameter.GetParentBucketItemOrParent();
if (!bucketItem.IsABucket())
{
return;
}
BucketManager.Sync(bucketItem);
}
}
}
On a bucket with a lot of items, this will considerably slow down the save process tho.
If I understood you right, you want your bucket item path to be based on date updated rather than created? Am I right with that?
If yes, that it is not going to be a straightforward thing to do. I see the following approach to implement that.
Configure your bucket to be organised by update date, not created (you mentioned you already know how to configure that behavior). Every Sitecore item derived from Standard Template should have Statistics section where is __Updated field (with two underscores a the beginning) that automatically updates on each item save by corresponding event. You should use that field.
Once done, sync all existing items to apply that bucketing items paths.
Handle item:saved event
Within item:saved event handler: unbucket that particular item and re-bucket that item again (with item:unbucket and item:bucket commands)
Your that particular item will be bucketed implementing your bucketing path rule.
Hope that helps!
Building on some of the answers, here's the most readable / performant solution for most use cases:
using Sitecore.Buckets.Extensions;
using Sitecore.Buckets.Managers;
using Sitecore.Data.Events;
using Sitecore.Diagnostics;
using System;
using Sitecore.Data.Items;
using Sitecore.Events;
namespace XXXX.Project.Web.Infrastructure.Pipelines
{
public class MoveItemIntoBucketOnSave
{
public void OnItemSaved(object sender, EventArgs args)
{
Assert.IsNotNull(sender, "sender is null");
Assert.IsNotNull(args, "args is null");
var savedItem = Event.ExtractParameter(args, 0) as Item;
if (savedItem == null || savedItem.Database.Name.ToLower() != "master" || !savedItem.IsItemBucketable())
{
return;
}
// WARNING: see update below about EventDisabler
using (new EventDisabler())
{
if (!BucketManager.IsItemContainedWithinBucket(savedItem))
{
return;
}
var bucketItem = savedItem.GetParentBucketItemOrParent();
if (!bucketItem.IsABucket())
{
return;
}
// If you want to sync the entire bucket
// BucketManager.Sync(bucketItem);
BucketManager.MoveItemIntoBucket(savedItem, bucketItem);
}
}
}
}
I'm not worried about there being any empty bucket folders after this operation since they will be cleaned up during a full bucket sync, and content authors would not typically be traversing the bucket tree as they should be using search.
Here's the config:
<?xml version="1.0"?>
<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
<sitecore>
<events>
<event name="item:saved">
<handler type="XXXX.Project.Web.Infrastructure.Pipelines.MoveItemIntoBucketOnSave, XXXX.Project.Web" method="OnItemSaved" />
</event>
</events>
</sitecore>
</configuration>
UPDATE: I do not recommend using the EventDisabler. If you add a new page and then try to add a rendering to the page and specify a datasource for it, the datasource locations won't resolve because Sitecore still thinks the path of newly created item is a direct child of the bucket item, rather than wherever the item was moved to within the bucket. See this question for more information.
UPDATE 2:
Note that this method will get called twice when a new bucketed item is created. You should think very carefully about what this means for you, and if you should add any other checks prior to calling any other code within this method.
You can achieve this by programmatically moving the bucketed item to the root of the bucket with the BucketManager. Doing this will force it to reevaluate the bucket rules and reorganize it:
BucketManager.MoveItemIntoBucket(bucketedItem, bucketItem);
Note that this is different from BucketManager.Sync(bucketItem) because it does not sync the whole bucket, but instead handles just the single item that was changed.
In our solutions, we typically create an item:saved event handler to do this automatically:
using Sitecore.Buckets.Managers;
using Sitecore.Buckets.Util;
using Sitecore.Data;
using Sitecore.Data.Items;
using Sitecore.Events;
using System;
using System.Text.RegularExpressions;
namespace Custom.Events.ItemSaved
{
public class ReorganizeBucketedItemInBucket
{
public void OnItemSaved(object sender, EventArgs args)
{
var bucketedItem = Event.ExtractParameter(args, 0) as Item;
// If we don't have an item or we're not saving in the master DB, ignore this save
if (bucketedItem == null || !"master".Equals(bucketedItem.Database?.Name, StringComparison.OrdinalIgnoreCase))
return;
if (!bucketedItem.TemplateID.Equals(new ID("{bucketed-item-template-id}"))) return;
var itemChanges = Event.ExtractParameter(args, 1) as ItemChanges;
// If there were no changes or the changes didn't include the date field, ignore this save
if (itemChanges == null || !itemChanges.HasFieldsChanged || !itemChanges.IsFieldModified(new ID("{field-id-of-date-field}")))
return;
Item bucketItem = bucketedItem.Axes.SelectSingleItem($"{EscapePath(bucketedItem.Paths.FullPath)}/ancestor-or-self::*[##templateid = '{{bucket-container-template-id}}']");
// If this item isn't in a bucket (or is in a bucket of another, unexpected type), ignore it
if (bucketItem == null) return;
Item parent = bucketedItem.Parent;
BucketManager.MoveItemIntoBucket(bucketedItem, bucketItem);
// Delete empty ancestor bucket folders
while (parent != null && !parent.HasChildren && parent.TemplateID == BucketConfigurationSettings.BucketTemplateId)
{
Item tempParent = parent.Parent;
parent.Delete();
parent = tempParent;
}
}
/// <summary>
/// Wraps each segment of a sitecore path with "#"'s
/// </summary>
public string EscapePath(string path)
{
return Regex.Replace(path, #"([^/]+)", "#$1#").Replace("#*#", "*");
}
}
}
And don't forget your patch config, of course:
<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
<sitecore>
<events>
<event name="item:saved">
<handler type="Custom.Events.ItemSaved.ReorganizeBucketedItemInBucket, Custom.Events" method="OnItemSaved"></handler>
</event>
</events>
</sitecore>
</configuration>
You'll need to implement a pipeline processor.
You can do this by adding the following into a .config file in your App_Code/Include folder.
<processors>
<saveUI>
<processor mode="on" type="Namespace.ClassName, Your.Assembly" patch:after="processor[last()]" />
</saveUI>
</processor
You'll also need to implement that class - there's nothing special about it except that it must have a public Process method with a Sitecore.Pipelines.Save.SaveArgs parameter.
namespace CustomFunctions
{
public class SaveAction
{
public void Process(SaveArgs args)
{
// There's a collection of items
// I'm not sure what the situation where there's more than one item is though.
var items = args.SavedItems;
var bucket = SomeFunctionToGetParent(items);
BucketManager.Sync(items);
}
}
}
I've never actually implemented this, but I think my code should give you an idea of how to get started - though this pipeline processor would be called every time an item is saved, so you need efficient checking to make sure that the item needs to have your bucket syncing processor used.
Is there any way to send mails to certain users based on a condition in ECM 2.1 . For example, I want to send mails to only those users whose user profile property Country='USA'. Is there a way to do this in ECM 2.1?
Earlier for ECM 1.3 we used to use a third party segmentation module below
https://marketplace.sitecore.net/en/Modules/Sitecore_EmailCampaign_Segment.aspx
But it does not support ECM 2.1. So I was wondering how to implement it in ECM 2.1 . By the way we are using Sitecore 7.2
If you don't mind extending ECM slightly you could tap into the DispatchNewsletter Pipline.
If you add processor like the following, you could get all the users dynamically and add them to the subscribers list. You just need to make sure that this only fires on certain scenarios to avoid this interfering with the core product functionality.
public class GetUSASubscribers
{
public void Process(DispatchNewsletterArgs args)
{
if(CanProcessEmail(args))
{
var matches = UserManager.GetUsers().Where(usr => usr.Profile["Country"].Equals("USA")).ToList();
foreach (var username in matches)
{
if (User.Exists(username.Name))
{
var contact = Contact.FromName(username.LocalName);
args.Message.Subscribers.Add(contact);
args.Message.SubscribersNames.Add(contact.Name);
}
}
}
}
}
You can register the processor as follows in your Sitecore.EmailCampaign.config
<DispatchNewsletter>
<processor type="Sitecore.Modules.EmailCampaign.Core.Pipelines.DispatchNewsletter.CheckPreconditions, Sitecore.EmailCampaign" />
<processor type="YourClass, YourNamespace" />
........................
</DispatchNewsletter>
To make it more dynamic you could add a Rules engine field to each message item to determine which users are added to the subscriber list. So the logic e.g where user profile["country"] equals 'USA' could be in the rules field.
For reference, some more detail on the set up of rules in Sitecore.
http://blog.horizontalintegration.com/2013/12/06/bending-the-sitecore-rules-field-to-your-will-with-sitecore-7-1-part-1/