public void ExtensionPoints()
{
Assert.AreEqual(2, desc.ExtensionPoints.Count);
ExtensionPoint ep1 = desc.ExtensionPoints [0];
Assert.AreEqual("/SimpleApp/TestEP1", ep1.Path);
Assert.AreEqual("TestEP1", ep1.Name);
Assert.AreEqual("Test EP1.", ep1.Description);
Assert.AreEqual(0, ep1.NodeSet.NodeTypes.Count);
Assert.AreEqual(1, ep1.NodeSet.NodeSets.Count);
Assert.AreEqual("TestSet", ep1.NodeSet.NodeSets[0]);
Assert.AreEqual(1, ep1.Conditions.Count);
Assert.AreEqual("TestCondition1", ep1.Conditions[0].Id);
ExtensionPoint ep2 = desc.ExtensionPoints [1];
Assert.AreEqual("/SimpleApp/TestEP2", ep2.Path);
Assert.AreEqual("TestEP2", ep2.Name);
Assert.AreEqual("Test EP2.", ep2.Description);
Assert.AreEqual(1, ep2.NodeSet.NodeTypes.Count);
ExtensionNodeType nt = ep2.NodeSet.NodeTypes[0];
Assert.AreEqual("Node", nt.NodeName);
Assert.AreEqual("Node description", nt.Description);
Assert.AreEqual(0, nt.NodeSets.Count);
Assert.AreEqual(1, nt.NodeTypes.Count);
nt = nt.NodeTypes [0];
Assert.AreEqual("Child", nt.NodeName);
Assert.AreEqual("SomeNodeType", nt.TypeName);
Assert.AreEqual("SomeObjectType", nt.ObjectTypeName);
Assert.AreEqual("SomeCustomAttrType", nt.ExtensionAttributeTypeName);
Assert.AreEqual("Child description", nt.Description);
}
public static bool TryAsNullable <T>(this ExtensionPoint <string> s, out Nullable <T> result, TryParseDelegate <T> parser)
where T : struct
{
bool flag;
T t = default(T);
if (!s.ExtendedValue.IsEmpty())
{
flag = parser(s.ExtendedValue, out t);
if (!flag)
{
result = null;
}
else
{
result = new Nullable <T>(t);
}
}
else
{
result = null;
flag = false;
}
return(flag);
}
public void Kentico_ValidArgument_ResultIsNotNull()
{
var routes = new RouteCollection();
ExtensionPoint <RouteCollection> extensionPoint = routes.Kentico();
Assert.IsNotNull(extensionPoint);
}
/// <summary>
/// 获取当前Bundle扩展点
/// </summary>
/// <returns>扩展点列表</returns>
public IList <ExtensionPoint> GetExtensionPoints()
{
var tmpExtensionPoints = new ExtensionPoint[extensionPoints.Count];
extensionPoints.CopyTo(tmpExtensionPoints, 0);
return(tmpExtensionPoints.ToList());
}
public void RegisterExtensionPoint(AddinDescription description, ExtensionPoint ep)
{
List <RootExtensionPoint> extensions;
if (pathHash.TryGetValue(ep.Path, out extensions))
{
// Extension point already registered
List <ExtensionPoint> compatExtensions = GetCompatibleExtensionPoints(ep.Path, description, description.MainModule, extensions);
if (compatExtensions.Count > 0)
{
foreach (ExtensionPoint einfo in compatExtensions)
{
einfo.MergeWith(null, ep);
}
RegisterObjectTypes(ep);
return;
}
}
// Create a new extension
RootExtensionPoint rep = new RootExtensionPoint();
rep.ExtensionPoint = ep;
rep.ExtensionPoint.RootAddin = description.AddinId;
rep.Description = description;
if (extensions == null)
{
extensions = new List <RootExtensionPoint> ();
pathHash [ep.Path] = extensions;
}
extensions.Add(rep);
RegisterObjectTypes(ep);
}
void RegisterObjectTypes(ExtensionPoint ep)
{
// Register extension points bound to a node type
foreach (ExtensionNodeType nt in ep.NodeSet.NodeTypes)
{
if (nt.ObjectTypeName.Length > 0)
{
List <ExtensionPoint> list;
if (!objectTypeExtensions.TryGetValue(nt.ObjectTypeName, out list))
{
list = new List <ExtensionPoint> ();
objectTypeExtensions [nt.ObjectTypeName] = list;
}
list.Add(ep);
}
if (nt.ExtensionAttributeTypeName.Length > 0)
{
List <ExtensionNodeType> list;
if (!customAttributeTypeExtensions.TryGetValue(nt.ExtensionAttributeTypeName, out list))
{
list = new List <ExtensionNodeType> ();
customAttributeTypeExtensions [nt.ExtensionAttributeTypeName] = list;
}
list.Add(nt);
}
}
}
/// <summary>
/// Visits an extension point and sets the parameters
/// </summary>
/// <param name="p">point to visit</param>
public override void VisitExtension(ExtensionPoint p)
{
_currentPoint = p;
// set the arguments
if (p.Graph.FunctionName == null)
{
return;
}
var declaration = p.Graph.SourceObject;
var signature = getSignature(declaration);
var callPoint = p.Caller as RCallPoint;
if (callPoint != null)
{
_currentPoint = callPoint;
if (signature.HasValue)
{
// We have names for passed arguments
setNamedArguments(OutputSet, callPoint.CallSignature, signature.Value, p.Arguments);
}
else
{
// There are no names - use numbered arguments
setOrderedArguments(OutputSet, p.Arguments, declaration);
}
}
}
/// <summary>
/// Creates the folder system based on the specified extension point.
/// </summary>
/// <param name="folderExtensionPoint"></param>
private void InitializeFolders(ExtensionPoint <IWorklistFolder> folderExtensionPoint)
{
AddDefaultFolders();
var worklistClassNames = new List <string>();
// collect worklist class names, and add unfiltered folders if authorized
foreach (IWorklistFolder folder in folderExtensionPoint.CreateExtensions())
{
if (!string.IsNullOrEmpty(folder.WorklistClassName))
{
worklistClassNames.Add(folder.WorklistClassName);
}
#if DEBUG // only available in debug builds (only used for testing)
// if unfiltered folders are visible, add the root folder
if (Thread.CurrentPrincipal.IsInRole(Application.Common.AuthorityTokens.Development.ViewUnfilteredWorkflowFolders))
{
this.Folders.Add(folder);
}
#endif
}
// query the set of worklists to which the current user is subscribed, add a folder for each
var response = QueryWorklistSet(new ListWorklistsForUserRequest(new List <string>(worklistClassNames)));
foreach (var summary in response.Worklists)
{
var added = AddWorklistFolderHelper(summary);
if (added == null)
{
Platform.Log(LogLevel.Error, string.Format("Worklist class {0} not added to folder system, most likely because it is not mapped to a folder class.", summary.ClassName));
}
}
}
ExtensionNodeTypeCollection GetAllowedChildTypes(TreeIter it)
{
ExtensionNodeTypeCollection types = null;
Extension ext = (Extension)store.GetValue(it, ColExtension);
if (ext != null)
{
if (ext.Parent == null)
{
ExtensionPoint ep = (ExtensionPoint)store.GetValue(it, ColExtensionPoint);
types = ep.NodeSet.GetAllowedNodeTypes();
}
else
{
types = ext.GetAllowedNodeTypes();
}
}
ExtensionNodeDescription node = (ExtensionNodeDescription)store.GetValue(it, ColNode);
if (node != null)
{
ExtensionNodeType tn = node.GetNodeType();
if (tn != null)
{
types = tn.GetAllowedNodeTypes();
}
}
return(types);
}
TreeIter AddExtensionPoint(ExtensionPoint extep, Extension ext)
{
string spath = ext.Path.Substring(extep.Path.Length);
spath = spath.Trim('/').Replace("/", " / ");
TreeIter ait = AddAddin(extep.ParentAddinDescription);
string name;
if (extep.Name.Length > 0)
{
name = GLib.Markup.EscapeText(extep.Name);
if (spath.Length > 0)
{
name += " / " + GLib.Markup.EscapeText(spath);
}
}
else if (extep.Description.Length > 0)
{
name = GLib.Markup.EscapeText(extep.Description);
if (spath.Length > 0)
{
name += " / " + GLib.Markup.EscapeText(spath);
}
}
else
{
name = GLib.Markup.EscapeText(extep.Path);
}
return(store.AppendValues(ait, name, null, ext, null, pixExtensionPoint, true, extep));
}
private Func <TradingSystem> CreateTradingSystemBuilder()
{
var extensionPoint = new ExtensionPoint(typeof(TradingSystem));
var tradingSystemType = extensionPoint.GetSingleImplementation(TradingSystem.Assembly, TradingSystem.Implementation);
return(() => BuildTradingSystem(tradingSystemType));
}
public FeatureViewModel(ExtensionPoint extPoint)
{
extensionPoint = extPoint;
name = extensionPoint.Name;
value = extensionPoint.Value;
icon = extensionPoint.Icon;
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
ExtensionPoint ep = (ExtensionPoint)dataObject;
if (treeBuilder.Options ["ShowExistingNodes"])
{
AddinRegistry reg = GetRegistry(treeBuilder);
if (reg == null)
{
return;
}
ExtensionNodeTree tree = new ExtensionNodeTree();
tree.Fill(reg, ep);
foreach (var node in tree.Nodes)
{
treeBuilder.AddChild(node);
}
}
else
{
int order = 0;
foreach (Extension ext in ep.ParentAddinDescription.MainModule.Extensions)
{
if (ext.Path == ep.Path)
{
foreach (ExtensionNodeDescription node in ext.ExtensionNodes)
{
treeBuilder.AddChild(new ExtensionNodeInfo(node, true, order++));
}
}
}
}
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Pixbuf icon, ref Pixbuf closedIcon)
{
ExtensionPoint ep = (ExtensionPoint)dataObject;
label = !string.IsNullOrEmpty(ep.Name) ? ep.Name : ep.Path;
icon = Context.GetIcon("md-extension-point");
}
public override void ActivateItem()
{
DotNetProject project = (DotNetProject)CurrentNode.GetParentDataItem(typeof(DotNetProject), true);
if (project == null)
{
return;
}
AddinData data = project.GetAddinData();
if (data == null)
{
return;
}
ExtensionPoint ep = (ExtensionPoint)CurrentNode.DataItem;
ExtensionPoint epc = new ExtensionPoint();
epc.CopyFrom(ep);
NewExtensionPointDialog epdlg = new NewExtensionPointDialog(project, data.AddinRegistry, data.CachedAddinManifest, epc);
if (epdlg.Run() == (int)Gtk.ResponseType.Ok)
{
ep.CopyFrom(epc);
data.CachedAddinManifest.Save();
}
epdlg.Destroy();
}
public void OnAddExtensionPoint()
{
DotNetProject project = (DotNetProject)CurrentNode.DataItem;
if (project == null)
{
return;
}
AddinData data = project.GetAddinData();
if (project == null)
{
return;
}
ExtensionPoint ep = new ExtensionPoint();
NewExtensionPointDialog dlg = new NewExtensionPointDialog(project, data.AddinRegistry, data.CachedAddinManifest, ep);
try {
if (dlg.Run() == (int)Gtk.ResponseType.Ok)
{
data.CachedAddinManifest.ExtensionPoints.Add(ep);
data.SaveAddinManifest();
data.NotifyChanged(false);
}
} finally {
dlg.Destroy();
}
}
IEnumerable GetExtensionInfo(Hashtable hash, string path, AddinDescription description, ModuleDescription module, bool lookInParents)
{
ArrayList list = new ArrayList();
object data = hash [path];
if (data == null && lookInParents)
{
// Root add-in extension points are registered before any other kind of extension,
// so we should find it now.
data = GetParentExtensionInfo(path);
}
if (data is ArrayList)
{
// Extension point which belongs to a root assembly.
list.AddRange(GetRootExtensionInfo(hash, path, description, module, (ArrayList)data));
}
else
{
ExtensionPoint info = (ExtensionPoint)data;
if (info == null)
{
info = new ExtensionPoint();
info.Path = path;
hash [path] = info;
}
list.Add(info);
}
return(list);
}
/// <summary>
/// Gets metadata describing all extensions of the input <paramref name="extensionPoint"/>,
/// matching the given <paramref name="filter"/>.
/// </summary>
/// <param name="extensionPoint">The <see cref="ExtensionPoint"/> whose extension metadata is to be retrieved.</param>
/// <param name="filter">An <see cref="ExtensionFilter"/> used to filter out extensions with particular characteristics.</param>
/// <returns></returns>
public virtual ExtensionInfo[] ListExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter)
{
if (extensionPoint == null)
{
throw new ArgumentNullException("extensionPoint");
}
var extensionPointType = extensionPoint.GetType();
if (!_extensionMap.ContainsKey(extensionPointType))
{
return(new ExtensionInfo[0]);
}
var extensions = new List <ExtensionInfo>();
foreach (var extensionType in _extensionMap[extensionPointType])
{
var extensionInfo = new ExtensionInfo(extensionType, extensionPointType, extensionType.Name, extensionType.AssemblyQualifiedName, true);
if (filter == null || filter.Test(extensionInfo))
{
extensions.Add(extensionInfo);
}
}
return(extensions.ToArray());
}
void AddExtension(Extension ext, IEnumerable <AddinDescription> deps)
{
ExtensionPoint extep = null;
foreach (AddinDescription desc in deps)
{
foreach (ExtensionPoint ep in desc.ExtensionPoints)
{
if (ep.Path == ext.Path || ext.Path.StartsWith(ep.Path + "/"))
{
extep = ep;
break;
}
}
if (extep != null)
{
break;
}
}
if (extep != null)
{
TreeIter it = AddExtensionPoint(extep, ext);
foreach (ExtensionNodeDescription node in ext.ExtensionNodes)
{
AddNode(it, node);
}
}
else
{
string txt = "<b>" + GLib.Markup.EscapeText(ext.Path) + "</b>\n";
txt += "<small><span foreground='red'>" + AddinManager.CurrentLocalizer.GetString("Unknown extension point") + "</span></small>";
store.AppendValues(txt, null, null, null, pixExtensionPoint, true, null);
}
}
public ExtensionInfo[] ListExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter)
{
Console.WriteLine(extensionPoint);
if (extensionPoint is ExpressionFactoryExtensionPoint)
return new[] { new ExtensionInfo(typeof(ConstantExpressionFactory), extensionPoint.GetType(), null, null, true), };
return new ExtensionInfo[0];
}
public ExtensionInfo[] ListExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter)
{
if (extensionPoint is CacheProviderExtensionPoint)
{
return(new[] { new ExtensionInfo(typeof(TestCacheProvider), typeof(CacheProviderExtensionPoint), null, null, true) });
}
throw new NotImplementedException();
}
public object[] CreateExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter, bool justOne)
{
Console.WriteLine(extensionPoint);
if (extensionPoint is ExpressionFactoryExtensionPoint)
return new object[] { new ConstantExpressionFactory() };
return new object[0];
}
public void RegisterExtension(AddinDescription description, ModuleDescription module, Extension extension)
{
if (extension.Path.StartsWith("$"))
{
string[] objectTypes = extension.Path.Substring(1).Split(',');
bool found = false;
foreach (string s in objectTypes)
{
List <ExtensionPoint> list;
if (objectTypeExtensions.TryGetValue(s, out list))
{
found = true;
foreach (ExtensionPoint ep in list)
{
if (IsAddinCompatible(ep.ParentAddinDescription, description, module))
{
extension.Path = ep.Path;
RegisterExtension(description, module, ep.Path);
}
}
}
}
if (!found)
{
monitor.ReportWarning("The add-in '" + description.AddinId + "' is trying to register the class '" + extension.Path.Substring(1) + "', but there isn't any add-in defining a suitable extension point");
}
}
else if (extension.Path.StartsWith("%", StringComparison.Ordinal))
{
string[] objectTypes = extension.Path.Substring(1).Split(',');
bool found = false;
foreach (string s in objectTypes)
{
List <ExtensionNodeType> list;
if (customAttributeTypeExtensions.TryGetValue(s, out list))
{
found = true;
foreach (ExtensionNodeType nt in list)
{
ExtensionPoint ep = (ExtensionPoint)((ExtensionNodeSet)nt.Parent).Parent;
if (IsAddinCompatible(ep.ParentAddinDescription, description, module))
{
extension.Path = ep.Path;
foreach (ExtensionNodeDescription node in GetNodesIgnoringConditions(extension))
{
node.NodeName = nt.NodeName;
}
RegisterExtension(description, module, ep.Path);
}
}
}
}
if (!found)
{
monitor.ReportWarning("The add-in '" + description.AddinId + "' is trying to register the class '" + extension.Path.Substring(1) + "', but there isn't any add-in defining a suitable extension point");
}
}
}
public object[] CreateExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter, bool justOne)
{
if (extensionPoint is CacheProviderExtensionPoint)
{
return(new[] { new TestCacheProvider() });
}
throw new NotImplementedException();
}
public object[] CreateExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter, bool justOne)
{
if (extensionPoint.GetType() == typeof(ProcedureStepBuilderExtensionPoint))
{
return(new object[] { new ModalityProcedureStepBuilder() });
}
return(new object[] { });
}
private void FireExtensionPointChanged(CollectionChangedAction action, ExtensionPoint extensionPoint)
{
ExtensionPointEventArgs args = new ExtensionPointEventArgs(this, action)
{
ExtensionPoint = extensionPoint
};
this.OnExtensionPointChanged(args);
}
public void OnAddExtension()
{
DotNetProject project = (DotNetProject)CurrentNode.DataItem;
if (project == null)
{
return;
}
AddinData data = project.GetAddinData();
if (project == null)
{
return;
}
AddinDescription adesc = data.CachedAddinManifest;
ExtensionSelectorDialog dlg = new ExtensionSelectorDialog(data.AddinRegistry, adesc, adesc.IsRoot, false);
if (dlg.Run() == (int)Gtk.ResponseType.Ok)
{
foreach (object ob in dlg.GetSelection())
{
AddinDescription desc = null;
if (ob is ExtensionPoint)
{
ExtensionPoint ep = (ExtensionPoint)ob;
Extension ext = new Extension(ep.Path);
adesc.MainModule.Extensions.Add(ext);
desc = (AddinDescription)ep.Parent;
}
else if (ob is ExtensionNodeDescription)
{
ExtensionNodeDescription node = (ExtensionNodeDescription)ob;
desc = node.ParentAddinDescription;
string path = "";
while (node != null && !(node.Parent is Extension))
{
if (!node.IsCondition)
{
path = "/" + node.Id + path;
}
node = node.Parent as ExtensionNodeDescription;
}
Extension eext = (Extension)node.Parent;
Extension ext = new Extension(eext.Path + "/" + node.Id + path);
adesc.MainModule.Extensions.Add(ext);
}
if (adesc.AddinId != desc.AddinId && !adesc.MainModule.DependsOnAddin(desc.AddinId))
{
adesc.MainModule.Dependencies.Add(new AddinDependency(desc.AddinId));
}
}
adesc.Save();
}
dlg.Destroy();
}
void FillExtensionPoint(TreeIter iter, ExtensionPoint ep)
{
// Add extension node types
FillExtensionNodeSet(iter, ep.NodeSet);
// Add extension nodes from known add-ins
ArrayList extensions = new ArrayList();
CollectExtensions(ep.ParentAddinDescription, ep.Path, extensions);
foreach (Dependency dep in ep.ParentAddinDescription.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
continue;
}
Addin addin = registry.GetAddin(adep.FullAddinId);
if (addin != null)
{
CollectExtensions(addin.Description, ep.Path, extensions);
}
}
// Sort the extensions, to make sure they are added in the correct order
// That is, deepest children last.
extensions.Sort(new ExtensionComparer());
// iter = store.AppendValues (iter, "Extensions", null, ep, false, false, null, false, true);
// Add the nodes
foreach (Extension ext in extensions)
{
string subp = ext.Path.Substring(ep.Path.Length);
TreeIter citer = iter;
ExtensionNodeSet ns = ep.NodeSet;
bool found = true;
foreach (string p in subp.Split('/'))
{
if (p.Length == 0)
{
continue;
}
if (!GetNodeBranch(citer, p, ns, out citer, out ns))
{
found = false;
break;
}
}
if (found)
{
FillNodes(citer, ns, ext.ExtensionNodes);
}
}
}
/// <summary>
/// Maps rich text inline editor routes.
/// </summary>
/// <param name="instance">Extension point for route collection.</param>
public static void MapRichTextInlineEditorRoutes(this ExtensionPoint <RouteCollection> instance)
{
instance = instance ?? throw new ArgumentNullException(nameof(instance));
instance.Target.MapHttpRoute(
name: RichTextInlineEditorConstants.GET_PAGE_ROUTE_NAME,
routeTemplate: RichTextInlineEditorConstants.GET_PAGE_ROUTE_TEMPLATE,
defaults: new { controller = RichTextInlineEditorConstants.CONTROLLER_NAME, action = nameof(KenticoRichTextController.GetPage) }
);
}
internal void CreateExtensionPoint(ExtensionPoint ep)
{
TreeNode node = tree.GetNode(ep.Path, true);
if (node.ExtensionPoint == null)
{
node.ExtensionPoint = ep;
node.ExtensionNodeSet = ep.NodeSet;
}
}
public ExtensionInfo[] ListExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter)
{
Console.WriteLine(extensionPoint);
if (extensionPoint.GetType() == typeof(ExpressionFactoryExtensionPoint))
return new ExtensionInfo[] { new ExtensionInfo(typeof(ConstantExpressionFactory), extensionPoint.GetType(), null, null, true), };
if (extensionPoint.GetType() == typeof(XmlSpecificationCompilerOperatorExtensionPoint))
return new ExtensionInfo[] { };
return new ExtensionInfo[0];
}
public object[] CreateExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter, bool justOne)
{
Console.WriteLine(extensionPoint);
if (extensionPoint.GetType() == typeof(ExpressionFactoryExtensionPoint))
return new object[] { new ConstantExpressionFactory() };
if (extensionPoint.GetType() == typeof(XmlSpecificationCompilerOperatorExtensionPoint))
return new object[]{};
return new object[0];
}
public object[] CreateExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter, bool justOne)
{
if (extensionPoint.GetType() == typeof(DicomCodecFactoryExtensionPoint))
{
return new object[] { new DicomRleCodecFactory() }
}
;
return(new object[0]);
}
/// <summary>
/// Converts the string representation of a <typeparamref name="T"/> struct to its nullable equivalent.
/// </summary>
/// <remarks>If the string <paramref name="s"/> is null, null will be returned.</remarks>
public static T?AsNullable <T>(this ExtensionPoint <string> s, Func <string, T> parser) where T : struct
{
T?result = null;
if (s.ExtendedValue.IsNotEmpty())
{
result = parser(s.ExtendedValue);
}
return(result);
}
protected CodeContractBaseRule([NotNull] string name, [NotNull] string ruleName, bool appliesToItem)
: base(name, typeof (CodeContractBaseRule).Assembly.GetName().Name + ".RuleMetadata",
typeof (CodeContractBaseRule).Assembly)
{
Guard.NotNull(ruleName, "ruleName");
this.ruleName = ruleName;
this.appliesToItem = appliesToItem;
ExternalAnnotationsRegistry =
new ExtensionPoint<ExternalAnnotationsMap>(DiskExternalAnnotationsLoader.Create);
}
/// <summary>
/// Returns an object that provides methods to add routes to Kentico HTTP handlers.
/// </summary>
/// <param name="target">The instance of the <see cref="RouteCollection"/> class.</param>
/// <returns>The object that provides methods to add routes to Kentico HTTP handlers.</returns>
public static ExtensionPoint<RouteCollection> Kentico(this RouteCollection target)
{
lock (mLock)
{
if (mExtensionPoint == null || mExtensionPoint.Target != target)
{
mExtensionPoint = new ExtensionPoint<RouteCollection>(target);
}
return mExtensionPoint;
}
}
/// <summary>
/// Returns an object that provides methods to build URLs to Kentico content.
/// </summary>
/// <param name="target">The instance of the <see cref="System.Web.Mvc.UrlHelper"/> class.</param>
/// <returns>The object that provides methods to build URLs to Kentico content.</returns>
public static ExtensionPoint<UrlHelper> Kentico(this UrlHelper target)
{
lock (mLock)
{
if (mExtensionPoint == null || mExtensionPoint.Target != target)
{
mExtensionPoint = new ExtensionPoint<UrlHelper>(target);
}
return mExtensionPoint;
}
}
protected CodeContractBaseRule([NotNull] string name, [NotNull] string ruleName, bool appliesToItem)
: base(name, typeof (CodeContractBaseRule).Assembly.GetName().Name + ".RuleMetadata",
typeof (CodeContractBaseRule).Assembly)
{
Guard.NotNull(ruleName, "ruleName");
this.ruleName = ruleName;
this.appliesToItem = appliesToItem;
ExternalAnnotationsResolver =
new ExtensionPoint<IExternalAnnotationsResolver>(() => new CachingExternalAnnotationsResolver());
}
private static string GenerateAttachmentUrl(ExtensionPoint<UrlHelper> instance, Attachment attachment, SizeConstraint constraint, AttachmentUrlOptions options)
{
var fileName = GetFileName(attachment);
var builder = new StringBuilder().AppendFormat("~/getattachment/{0:D}/{1}", attachment.GUID, GetFileNameForUrl(fileName));
var referenceLength = builder.Length;
Action<string, object> append = (name, value) =>
{
builder.Append(builder.Length == referenceLength ? '?' : '&').Append(name).Append('=').Append(value);
};
if (constraint.WidthComponent > 0)
{
append("width", constraint.WidthComponent);
}
if (constraint.HeightComponent > 0)
{
append("height", constraint.HeightComponent);
}
if (constraint.MaxWidthOrHeightComponent > 0)
{
append("maxsidesize", constraint.MaxWidthOrHeightComponent);
}
// Prevent Kentico from using site settings
if (!constraint.IsEmpty)
{
append("resizemode", "force");
}
if ((options != null) && options.AttachmentContentDisposition)
{
append("disposition", "attachment");
}
var url = builder.ToString();
if (attachment.VersionID > 0)
{
url = GetAttachmentPreviewUrl(url);
}
return instance.Target.Content(url);
}
private Func<TradingSystem> CreateTradingSystemBuilder()
{
var extensionPoint = new ExtensionPoint( typeof( TradingSystem ) );
var tradingSystemType = extensionPoint.GetSingleImplementation( TradingSystem.Assembly, TradingSystem.Implementation );
return () => BuildTradingSystem( tradingSystemType );
}
/// <summary>
/// Returns an empty array.
/// </summary>
public virtual ExtensionInfo[] ListExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter)
{
return new ExtensionInfo[] { };
}
/// <summary>
/// Return an empty array.
/// </summary>
public virtual object[] CreateExtensions(ExtensionPoint extensionPoint, ExtensionFilter filter, bool justOne)
{
return new object[] { };
}