public static GetMongoZipPipelineArgs Run(MongoCollection collection, int zipCode)
{
var args = new GetMongoZipPipelineArgs(collection, zipCode);
CorePipeline.Run("zipCode.getMongoZip", args);
return(args);
}
public virtual IHtmlString RenderBeginField(object parameters, bool editing = true)
{
var renderFieldArgs = new RenderFieldArgs
{
Item = Field.Item,
FieldName = Field.Name,
DisableWebEdit = !editing
};
if (parameters != null)
{
TypeHelper.CopyProperties(parameters, renderFieldArgs);
TypeHelper.CopyProperties(parameters, renderFieldArgs.Parameters);
}
if (renderFieldArgs.Item == null)
{
return(new HtmlString(string.Empty));
}
CorePipeline.Run("renderField", renderFieldArgs);
var result = renderFieldArgs.Result;
var str = result.FirstPart ?? string.Empty;
EndFieldStack.Push(result.LastPart ?? string.Empty);
return(new HtmlString(str));
}
public void ShouldBeThreadSafePipelines()
{
var t1 = Task.Factory.StartNew(() =>
{
using (var db = new Db())
{
db.PipelineWatcher.Expects("mypipeline");
Thread.Sleep(1000);
CorePipeline.Run("mypipeline", new PipelineArgs());
db.PipelineWatcher.EnsureExpectations();
}
});
var t2 = Task.Factory.StartNew(() =>
{
using (new Db())
{
}
});
t1.Wait();
t2.Wait();
}
public virtual void Process(GetLookupSourceItemsArgs args)
{
var replaceTokensArgs = new ReplaceLookupSourceQueryTokensArgs(args.Item, args.Source);
CorePipeline.Run("elision.replaceLookupSourceQueryTokens", replaceTokensArgs);
args.Source = replaceTokensArgs.Query;
}
private void LoadDescendants(
IndexFileItem parentFileItem,
Item parent,
SerializationManager serializationManager,
DirectoryInfo parentDirectory)
{
foreach (var child in parentFileItem.Children)
{
Item item = parent.Database.GetItem(ID.Parse(child.Id));
if (item == null)
{
ItemFile itemFile = serializationManager
.ReadItemFile(GetItemFileInfo(parentDirectory, child.Id));
item = ItemManager.CreateItem(
itemFile.Name,
parent,
ID.Parse(itemFile.TemplateId),
ID.Parse(itemFile.Id),
SecurityCheck.Disable);
}
CorePipeline.Run(revert ? "serialization.revertitem" : "serialization.loaditem",
new CustomSerializationPipelineArgs()
{
SerializationManager = serializationManager,
Item = item
});
LoadDescendants(child, item, serializationManager, parentDirectory);
}
}
private object CreateResult(IEnumerable <Rendering> renderings)
{
var args = new GetModelArgs(renderings);
CorePipeline.Run("headless.getModel", args, false);
return(args.Result);
}
public void Process(HandleKeyPhrasesResponsePipelineArgs args)
{
if (args?.Collection?.Documents == null)
{
Log.Warn($"ScoreContentWithKeyPhrases skipped due to a null argument", this);
return;
}
var database = _factory.GetDatabase("master"); // TODO: move this to config and inject
foreach (var model in args.Collection.Documents)
{
if (!ID.TryParse(model.Id, out var id))
{
continue;
}
var scoreContentArgs = new ScoreContentPipelineArgs()
{
Item = database.GetItem(id),
KeyPhrases = model.KeyPhrases
};
CorePipeline.Run("scoreContent", scoreContentArgs); // TODO: move this to config and inject
}
}
/// <summary>
/// Gets the rendering item.
/// </summary>
/// <returns></returns>
public virtual Item GetRenderingItem()
{
var args = new GetRenderingItemArgs(RenderingContext.Current);
CorePipeline.Run("xWrap.getRenderingItem", args);
return(args.RenderingItem);
}
protected override void ProcessOptimize(ProcessorArgs args)
{
if (_supportedExtensionsLookup.Contains(args.InputStream.Extension))
{
if (args.ResultStream == null)
{
// MakeStreamSeekable will buffer the stream if its not seekable
args.InputStream.MakeStreamSeekable();
args.InputStream.Stream.Seek(0, SeekOrigin.Begin);
}
var sourceStream = args.ResultStream ?? args.InputStream.Stream;
var optimizerArgs = new OptimizerArgs(sourceStream, args.MediaOptions);
CorePipeline.Run(Pipeline, optimizerArgs);
args.IsOptimized = optimizerArgs.IsOptimized;
args.Extension = optimizerArgs.Extension;
args.ResultStream = optimizerArgs.Stream;
if (!string.IsNullOrEmpty(optimizerArgs.Message))
{
args.AddMessage(optimizerArgs.Message);
}
if (optimizerArgs.Aborted)
{
args.AbortPipeline();
}
}
}
protected override Item ResolveCompositeDatasource(string datasource, Item contextItem)
{
ID datasourceId;
if (ID.TryParse(datasource, out datasourceId))
{
var datasourceItem = Context.Database.GetItem(datasourceId);
if (datasourceItem.TemplateID == Templates.RulesBasedSnippetSnippet.ID)
{
var rulesBasedDatasource = rulesBasedSnippetRepository.GetRulesBasedSnippetDataSource(datasourceItem, contextItem);
return(rulesBasedDatasource ?? datasourceItem);
}
else
{
return(datasourceItem);
}
}
ResolveRenderingDatasourceArgs renderingDatasourceArgs = new ResolveRenderingDatasourceArgs(datasource);
if (contextItem != null)
{
renderingDatasourceArgs.CustomData.Add(nameof(contextItem), contextItem);
}
CorePipeline.Run("resolveRenderingDatasource", renderingDatasourceArgs);
return(Context.Database.GetItem(renderingDatasourceArgs.Datasource));
}
public void InjectPrefab(RenderingItem prefabProxy, DeviceDefinition deviceLayout, string placeholderPath, int index, Item pageItem)
{
var getItemArgs = new PrefabsGetItemArgs {
DeviceLayout = deviceLayout,
DestinationPlaceholderPath = placeholderPath,
PrefabProxy = prefabProxy,
PageItem = pageItem
};
CorePipeline.Run("prefabsGetItem", getItemArgs);
if (!getItemArgs.Handled || getItemArgs.Result == null)
{
throw new System.Exception($"Prefab not found");
}
var getRenderingsArgs = new PrefabGetRenderingsArgs
{
Prefab = getItemArgs.Result,
DeviceLayout = deviceLayout,
DestinationPlaceholderPath = placeholderPath,
PrefabProxy = prefabProxy,
PageItem = pageItem,
Index = index
};
CorePipeline.Run("prefabGetRenderings", getRenderingsArgs);
if (!getRenderingsArgs.Handled)
{
throw new System.Exception($"Prefab had no renderings to add");
}
getRenderingsArgs.Reuse();
CorePipeline.Run("prefabApplyRenderings", getRenderingsArgs);
}
private static Url BuildUrl(List <Link> links, SitemapItem sitemapItem, bool languageFallbackEnabled)
{
var matchedItem = links.FirstOrDefault(link => link.Item == sitemapItem.Item);
if (matchedItem == null)
{
Logger.Warn(
$"Unable to retrieve item from alternate links: {sitemapItem.Item.Paths.FullPath}, language: {sitemapItem.Item.Language.Name}");
return(null);
}
var loc = matchedItem.Href;
var sitemapGetModifiedDateArgs = new SitemapGetModifiedDateArgs(sitemapItem.Item, DateTime.MinValue, languageFallbackEnabled);
CorePipeline.Run("sitemap.GetModifiedDate", sitemapGetModifiedDateArgs);
var lastmod = sitemapGetModifiedDateArgs.LastModified;
if (lastmod == DateTime.MinValue)
{
Logger.Warn(
$"No modified date found for item: {sitemapItem.Item.Paths.FullPath}, language: {sitemapItem.Item.Language.Name}");
return(null);
}
var url = new Url
{
Loc = loc,
Lastmod = lastmod.ToString("yyyy-MM-dd"),
Link = links
};
return(url);
}
/// <summary>
/// Runs the package generation
/// </summary>
/// <param name="args">The client pipeline arguments.</param>
protected virtual void Run(ClientPipelineArgs args)
{
if (!args.IsPostBack)
{
SheerResponse.Input(
Translate.Text("Please enter package name"),
Translate.Text("Unnamed Package"),
@"^(?!\s*$).+",
Translate.Text("Invalid package name"),
255,
Translate.Text("Generate Package"));
args.WaitForPostBack();
}
else if (args.HasResult)
{
var pipelineArgs = new GeneratePackagePipelineArgs
{
PackageName = args.Result,
PackageAuthor = Context.User.DisplayName
};
CorePipeline.Run("PackMan.GeneratePackage", pipelineArgs);
if (!string.IsNullOrWhiteSpace(pipelineArgs.DownloadPath))
{
Context.ClientPage.ClientResponse.Download(pipelineArgs.DownloadPath);
}
else
{
Context.ClientPage.ClientResponse.Alert(string.Format("Failed to generate package '{0}'", pipelineArgs.PackageName));
}
}
}
private MediaStream GetImageStream(MediaStream stream, TransformationOptions options)
{
Assert.ArgumentNotNull((object)stream, nameof(stream));
Assert.ArgumentNotNull((object)options, nameof(options));
var mediaOptions = new MediaOptions()
{
AllowStretch = options.AllowStretch,
BackgroundColor = options.BackgroundColor,
IgnoreAspectRatio = options.IgnoreAspectRatio,
Scale = options.Scale,
Width = options.Size.Width,
Height = options.Size.Height,
MaxWidth = options.MaxSize.Width,
MaxHeight = options.MaxSize.Height
};
mediaOptions.CustomOptions["extension"] = "webp";
var args = new OptimizerArgs(stream.Stream, mediaOptions);
CorePipeline.Run("dianogaOptimizeWebP", args);
if (args.IsOptimized)
{
return(new MediaStream(args.Stream, args.Extension, stream.MediaItem));
}
return(null);
}
private void CreateVersionItems(RequestArgs args)
{
Assert.ArgumentNotNull(args, "args");
Item[] scope = args.Scope;
Assert.IsNotNull(scope, "The scope is null.");
string queryString = WebUtil.GetQueryString("items");
Item[] items = null;
if (queryString != null && queryString.Length > 0 && queryString.Contains('|'))
{
items = Common.Functions.GetItems(queryString.Split('|'));
}
else if (queryString != null && queryString.Length > 0)
{
items = new Item[1];
}
items[0] = Common.Functions.GetItem(queryString);
if (items == null)
{
throw new ArgumentException("Items not found.");
}
Item[] scope2 = (scope.Length > 0) ? new Item[]
{
scope.First <Item>()
} : new Item[0];
CreateVersionArgs createVersionArgs = new CreateVersionArgs(scope2)
{
Scope = items
};
CorePipeline.Run("itemWebApiCreateVersion", createVersionArgs);
args.Result = createVersionArgs.Result;
}
public ActionResult Login()
{
ActionResult result;
try
{
DoLoginPipelineArgs pipelineArgs = new DoLoginPipelineArgs {
HttpContext = HttpContext
};
if (!string.IsNullOrEmpty(Request.QueryString["returnurl"]))
{
pipelineArgs.ReturnUrlQueryString = new Uri(Request.QueryString["returnurl"], UriKind.RelativeOrAbsolute);
}
CorePipeline.Run("doLogin", pipelineArgs);
result = pipelineArgs.PostLoginAction;
}
catch (SecurityException ex)
{
Log.Info(ex.Message, this);
result = new RedirectResult(
$"/{Context.Language.Name.ToLowerInvariant()}/{Settings.NoAccessUrl.WithoutPrefix('/')}",
false);
}
return(result);
}
public void ShouldCallAndCheclListOfPipelinesWithArgs()
{
// arrange
var args1 = new PipelineArgs();
args1.CustomData["key1"] = "value1";
var args2 = new PipelineArgs();
args2.CustomData["key2"] = "value2";
this.watcher
.WhenCall("pipeline1")
.WithArgs(a => a.CustomData.ContainsKey("key1"))
.Then(a => a.CustomData["key1"] = "new value1");
this.watcher
.WhenCall("pipeline2")
.WithArgs(a => a.CustomData.ContainsKey("key2"))
.Then(a => a.CustomData["key2"] = "new value2");
// act
CorePipeline.Run("pipeline1", args1);
CorePipeline.Run("pipeline2", args2);
// assert
args1.CustomData["key1"].Should().Be("new value1");
args2.CustomData["key2"].Should().Be("new value2");
}
protected override IPlugin ExecuteServicePipeline(string servicePipelineName, BaseAzureServicePipelineArgs servicePipelineArgs, ILogger logger)
{
// get the pipeline from the config
CorePipeline.Run(servicePipelineName, servicePipelineArgs, Sitecore.Configuration.Settings.GetSetting("PaaSPort.PipelineGroupName"));
return(servicePipelineArgs.GetResult());
}
private IEnumerable <Rendering> GetRenderings()
{
var args = new GetRenderingsArgs(ControllerContext.RequestContext);
CorePipeline.Run("headless.getRenderings", args, false);
return(args.Result ?? Enumerable.Empty <Rendering>());
}
protected override IEnumerable <ID> GetProductsItemIdList()
{
CustomGetRecommendedProductsArgs productsPipelineArgs = this.GetRecommendedProductsPipelineArgs();
CorePipeline.Run("commerce.getRecommendedProducts", productsPipelineArgs);
return(productsPipelineArgs.RecommendedProductsIdList);
}
public static NameValueCollection GetSourceString(string itemId, string itemLanguage, string source)
{
var current = Sitecore.Context.ContentDatabase.GetItem(new ID(itemId), Language.Parse(itemLanguage));
var lookupSourceItemsArgs = new GetLookupSourceItemsArgs
{
Item = current,
Source = source
};
try
{
using (new LongRunningOperationWatcher(1000, "getLookupSourceItems pipeline[item={0}, source={1}]", current.Paths.Path, source))
{
CorePipeline.Run("getLookupSourceItems", lookupSourceItemsArgs);
}
}
catch (Exception ex)
{
throw new LookupSourceException(source, ex);
}
var parsedSource = HttpUtility.ParseQueryString(lookupSourceItemsArgs.Source.ToLower());
return(parsedSource);
}
public IFieldRenderingResult Render(object parameters = null)
{
var renderFieldArgs = new RenderFieldArgs()
{
Item = item,
FieldName = fieldName
};
if (parameters != null)
{
renderFieldArgs.ApplyParameters(parameters);
}
CorePipeline.Run(renderFieldPipeline, renderFieldArgs);
var result = renderFieldArgs.Result;
var beginResult = result?.FirstPart;
var endResult = result?.LastPart;
var renderingResult = new FieldRenderingResult(beginResult, endResult);
RenderingResult = renderingResult.Some <IFieldRenderingResult>();
return(renderingResult);
}
public static HtmlString BeginField(ID fieldId, Item item, object parameters)
{
Assert.ArgumentNotNull(fieldId, nameof(fieldId));
var renderFieldArgs = new RenderFieldArgs
{
Item = item,
FieldName = item.Fields[fieldId].Name
};
if (parameters != null)
{
CopyProperties(parameters, renderFieldArgs);
CopyProperties(parameters, renderFieldArgs.Parameters);
}
renderFieldArgs.Item = renderFieldArgs.Item ?? CurrentItem;
if (renderFieldArgs.Item == null)
{
EndFieldStack.Push(string.Empty);
return(new HtmlString(string.Empty));
}
CorePipeline.Run("renderField", renderFieldArgs);
var result1 = renderFieldArgs.Result;
var str = result1.ValueOrDefault(result => result.FirstPart).OrEmpty();
EndFieldStack.Push(result1.ValueOrDefault(result => result.LastPart).OrEmpty());
return(new HtmlString(str));
}
/// <summary>
/// Gets the entity instance.
/// </summary>
/// <typeparam name="T">The entity contract.</typeparam>
/// <returns>The entity instance.</returns>
public virtual T GetConfiguration <T>() where T : class
{
var entityName = string.Format("{0}_{1}", Sitecore.Context.Site.Name, Sitecore.Context.Database.Name);
try
{
var args = new ConfigurationPipelineArgs(typeof(T))
{
EntityName = entityName
};
CorePipeline.Run("getConfiguration", args);
Assert.IsNotNull(args.ConfigurationItem, typeof(T), "Unable to resolve '\"{0}\"' configuration.", typeof(T).Name);
this.innerContainer.RegisterInstance(entityName, (T)args.ConfigurationItem);
return((T)args.ConfigurationItem);
}
catch (Exception exception)
{
Log.Warn(exception.Message, exception);
lock (this)
{
return(UnityContainerExtensions.Resolve <T>(this));
}
}
}
public ResponsePlaceholder(Item contextItem, LayoutDefinition layoutDefinition, string name, string parentUniqueId, bool exists = true, bool dynamic = true)
{
Name = name;
ParentUniqueId = parentUniqueId;
Exists = exists;
Icon = "<img src=\"/temp/IconCache/Business/16x16/table_selection_block.png\" alt=\"\" />";
Dynamic = dynamic;
//DynamicPlaceholderName = name + "-" + ParentUniqueId + "";
ValidRenderings = new List <ResponsePlaceholderRendering>();
// TODO: find all the valid renderings!
GetPlaceholderRenderingsArgs args = new GetPlaceholderRenderingsArgs(Name, layoutDefinition.ToXml(), contextItem.Database);
//args.ContextItemPath = contextItem.Paths.FullPath;
//args.ShowDialogIfDatasourceSetOnRenderingItem = true;
CorePipeline.Run("getPlaceholderRenderings", args);
if (args.PlaceholderRenderings != null)
{
foreach (var placeholderRendering in args.PlaceholderRenderings)
{
ValidRenderings.Add(new ResponsePlaceholderRendering(placeholderRendering, layoutDefinition, contextItem));
}
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <param name="disposing">True if disposing, otherwise false.</param>
protected virtual void Dispose(bool disposing)
{
if (this.disposed)
{
return;
}
if (!disposing)
{
return;
}
CorePipeline.Run("releaseFakeDb", new ReleaseDbArgs(this));
this.dataStorageSwitcher.Dispose();
this.databaseSwitcher.Dispose();
foreach (var languageSwitcher in this.databaseLanguages)
{
if (Switcher <DbLanguages> .CurrentValue != null)
{
languageSwitcher.Dispose();
}
}
if (Monitor.IsEntered(Lock))
{
Monitor.Exit(Lock);
}
this.disposed = true;
}
/// <remarks>All roots must live within the same configuration! Make sure that the roots are from the target data store.</remarks>
public virtual bool SyncTree(IConfiguration configuration, Action <IItemData> rootLoadedCallback = null, params IItemData[] roots)
{
var logger = configuration.Resolve <ILogger>();
var beginArgs = new UnicornSyncBeginPipelineArgs(configuration);
CorePipeline.Run("unicornSyncBegin", beginArgs);
if (beginArgs.Aborted)
{
logger.Error("Unicorn Sync Begin pipeline was aborted. Not executing sync for this configuration.");
return(false);
}
if (beginArgs.SyncIsHandled)
{
logger.Info("Unicorn Sync Begin pipeline signalled that it handled the sync for this configuration.");
return(true);
}
var syncStartTimestamp = DateTime.Now;
using (new TransparentSyncDisabler())
{
var retryer = configuration.Resolve <IDeserializeFailureRetryer>();
var consistencyChecker = configuration.Resolve <IConsistencyChecker>();
var loader = configuration.Resolve <SerializationLoader>();
loader.LoadAll(roots, retryer, consistencyChecker, rootLoadedCallback);
}
CorePipeline.Run("unicornSyncComplete", new UnicornSyncCompletePipelineArgs(configuration, syncStartTimestamp));
return(true);
}
private void UpdateMediaItem(RequestArgs args)
{
Assert.ArgumentNotNull(args, "args");
Item item = args.Context.Item;
if (item == null)
{
throw new BadRequestException("The specified location not found.");
}
Database database = args.Context.Database;
Assert.IsNotNull(database, "Database not resolved.");
Sitecore.Globalization.Language currentLanguage = args.Context.Language;
if (!item.Access.CanCreate())
{
throw new AccessDeniedException(string.Format("Access denied (access right: 'item:create', item: '{0}')", item.Paths.ParentPath));
}
HttpFileCollection files = args.Context.HttpContext.Request.Files;
List <Item> list = new List <Item>();
MediaItem mediaItem = Common.Functions.UpdateMediaItem(item, args.Context.HttpContext);
if (mediaItem != null)
{
list.Add(mediaItem.InnerItem);
ReadArgs readArgs = new ReadArgs(list.ToArray());
CorePipeline.Run("itemWebApiRead", readArgs);
args.Result = readArgs.Result;
}
}
public MigrateItemPipelineArgs Run(ItemModel source)
{
var args = new MigrateItemPipelineArgs {
Source = source
};
try
{
var stopWatch = new Stopwatch();
stopWatch.Start();
CorePipeline.Run("migrateItem", args, "OneNorth.Migrator");
stopWatch.Stop();
if (args.Item == null)
{
Sitecore.Diagnostics.Log.Warn(string.Format("[FieldMigrator] (MigrateItemPipeline) Did not migrate: {0} {1} in {2}", source.Id, source.FullPath(x => x.Parent, x => x.Name), stopWatch.Elapsed), this);
}
else
{
Sitecore.Diagnostics.Log.Info(string.Format("[FieldMigrator] (MigrateItemPipeline) Migrated: {0} {1} in {2}", args.Item.ID, args.Item.Paths.FullPath, stopWatch.Elapsed), this);
}
}
catch (Exception ex)
{
Sitecore.Diagnostics.Log.Error(string.Format("[FieldMigrator] (MigrateItemPipeline) {0} {1}", source.Id, source.FullPath(x => x.Parent, x => x.Name)), ex, this);
}
return(args);
}
protected ServiceProviderResult CreateAddressProfile(string id, ref Profile profile)
{
ServiceProviderResult result = new ServiceProviderResult {
Success = true
};
try
{
var createArgs = new CreateProfileArgs();
createArgs.InputParameters.Name = "Address";
createArgs.InputParameters.Id = id;
CorePipeline.Run(CommerceConstants.PipelineNames.CreateProfile, createArgs);
profile = createArgs.OutputParameters.CommerceProfile;
}
catch (Exception e)
{
result = new ServiceProviderResult {
Success = false
};
result.SystemMessages.Add(new SystemMessage {
Message = e.Message
});
}
return(result);
}
