/// <summary>
/// Method is called when a plugin that implements this interface is loaded.
/// Usually this method contains code which creates rule actions and performs
/// corrections to the resources created during the first start of the plugin.
/// </summary>
public void RegisterViewsEachRun()
{
string[] applType = new string[] { "RSSItem" };
IFilterRegistry fMgr = Core.FilterRegistry;
INotificationManager notifMgr = Core.NotificationManager;
notifMgr.RegisterNotifyMeResourceType("RSSFeed", "RSSItem");
notifMgr.RegisterNotifyMeResourceType("RSSItem", "RSSItem");
// Conditions/Templates
IResource feedCondition = fMgr.CreateConditionTemplate(PostInFeedName, PostInFeedDeep, applType, ConditionOp.In, "RSSFeed", "RSSItem");
fMgr.AssociateConditionWithGroup(feedCondition, RSSConditionsGroup);
notifMgr.RegisterNotifyMeCondition("RSSFeed", feedCondition, 0);
notifMgr.RegisterNotifyMeCondition("RSSItem", feedCondition, -Props.RSSItem);
feedCondition = fMgr.RegisterCustomCondition(PostInSearchFeedName, PostInSearchFeedDeep, applType, new PostInSearchFeedCondition());
fMgr.AssociateConditionWithGroup(feedCondition, RSSConditionsGroup);
feedCondition = fMgr.RegisterCustomCondition(PostIsAuthorsCommentName, PostIsAuthorsCommentDeep, applType, new PostIsAuthorsCommentCondition());
fMgr.AssociateConditionWithGroup(feedCondition, RSSConditionsGroup);
// Rule Actions
Core.FilterEngine.RegisterRuleApplicableResourceType("RSSItem");
fMgr.RegisterRuleAction(DownloadEnclosureName, DownloadEnclosureDeep, new EnclosureDownloadRuleAction(), applType);
fMgr.RegisterRuleActionTemplate(DownloadEnclosureToName, DownloadEnclosureToDeep, new EnclosureDownloadToDirRuleActionTemplate(),
applType, ConditionOp.In, "ExternalDir");
}
// IFilterRegistry in params is mostly for PicoContainer dependency.
public FormattingRuleManager(IFilterRegistry fmgr)
{
_fmgr = fmgr;
RegisterTypes();
CheckValidInvisibleRules();
SetupFormattingRules();
}
public void RegisterFilters(IFilterRegistry filterRegistry)
{
filterRegistry.Add(Enumerable.Empty <IFilterCriteria>(), typeof(ContentItemFilter));
ControllerActionFilterCriteria contentItemsInputCriteria = new ControllerActionFilterCriteria();
contentItemsInputCriteria.AddMethod <PageController>(p => p.Edit(null, null));
contentItemsInputCriteria.AddMethod <PageController>(p => p.SaveEdit(null, null));
filterRegistry.Add(new[] { contentItemsInputCriteria }, typeof(ContentItemsInputFilter));
ControllerActionFilterCriteria pageListActionCriteria = new ControllerActionFilterCriteria();
pageListActionCriteria.AddMethod <PageController>(p => p.Add(null));
pageListActionCriteria.AddMethod <PageController>(p => p.AddSave(null));
pageListActionCriteria.AddMethod <PageController>(p => p.Edit(null, null));
pageListActionCriteria.AddMethod <PageController>(p => p.SaveEdit(null, null));
filterRegistry.Add(new[] { pageListActionCriteria }, typeof(PageListActionFilter));
ControllerActionFilterCriteria adminActionsCriteria = new ControllerActionFilterCriteria();
adminActionsCriteria.AddMethod <PageController>(p => p.Add(null));
adminActionsCriteria.AddMethod <PageController>(p => p.AddSave(null));
adminActionsCriteria.AddMethod <PageController>(p => p.Edit(null, null));
adminActionsCriteria.AddMethod <PageController>(p => p.SaveEdit(null, null));
adminActionsCriteria.AddMethod <PageController>(p => p.Remove(null, null));
filterRegistry.Add(new[] { adminActionsCriteria }, typeof(AuthorizationFilter));
}
//---------------------------------------------------------------------
// Register mail-dependent conditions, views and rules
//---------------------------------------------------------------------
void IViewsConstructor.RegisterViewsFirstRun()
{
string[] applTypes = new string[1] {
STR.Email
};
IFilterRegistry fMgr = Core.FilterRegistry;
IResource cond;
cond = fMgr.CreateConditionTemplate(LocatesInFolderName, LocatesInFolderDeep, applTypes, ConditionOp.In, STR.MAPIFolder, STR.MAPIFolder);
fMgr.AssociateConditionWithGroup(cond, "Email Conditions");
cond = fMgr.CreateConditionTemplate(SentViaAccountName, SentViaAccountDeep, applTypes, ConditionOp.In, "EmailAccount", "EmailAccountTo");
fMgr.AssociateConditionWithGroup(cond, "Address and Contact Conditions");
cond = fMgr.CreateStandardCondition(HasAttachmentName, HasAttachmentDeep, applTypes, "Attachment", ConditionOp.HasLink);
fMgr.AssociateConditionWithGroup(cond, "Email Conditions");
cond = fMgr.CreateConditionTemplate(SentToMailingListXName, SentToMailingListXDeep, applTypes, ConditionOp.In, "MailingList", "To");
fMgr.AssociateConditionWithGroup(cond, "Address and Contact Conditions");
IResource myResType = Core.ResourceStore.FindUniqueResource("ResourceType", Core.Props.Name, STR.Email);
cond = fMgr.CreateStandardCondition(AuthorPostedMailName, AuthorPostedMailDeep, new string[] { "Contact" },
"LinkedResourcesOfType", ConditionOp.In, myResType.ToResourceList());
fMgr.AssociateConditionWithGroup(cond, "Address and Contact Conditions");
}
public void RegisterViewsFirstRun()
{
// Link all tasks created so far to the root with the
// new predefined link.
IResourceList list = Core.ResourceStore.GetAllResources("Task");
foreach (IResource res in list)
{
if (res.GetLinksOfType(null, TasksPlugin._linkSuperTask).Count == 0)
{
IResource rootTask = res.GetLinkProp(TasksPlugin._linkTarget);
res.SetProp(TasksPlugin._linkSuperTask, rootTask);
}
}
// Tasks for "Next Week" view.
IFilterRegistry fMgr = Core.FilterRegistry;
IStandardConditions std = fMgr.Std;
string[] applType = new string[1] {
"Task"
};
IResource dateRes = fMgr.CreateConditionTemplate(std.ReceivedInTheTimeSpanXName, std.ReceivedInTheTimeSpanXNameDeep, null, ConditionOp.In, "Date");
IResource nextWeekCond = FilterConvertors.InstantiateTemplate(dateRes, "Next Week", null);
IResource completed = fMgr.CreateStandardCondition(TasksViewsConstructor.TaskIsCompletedName, TasksViewsConstructor.TaskIsCompletedDeep, applType, "Status", ConditionOp.Eq, "2");
IResource tasksNextWeek = fMgr.RegisterView("Due Next Week", applType, new IResource[1] {
nextWeekCond
}, new IResource[1] {
completed
});
Core.ResourceTreeManager.LinkToResourceRoot(tasksNextWeek, 9);
}
private static void RegisterRulesActions()
{
IResource res;
IFilterRegistry fmgr = Core.FilterRegistry;
IStandardConditions std = fmgr.Std;
// Register them here since they require live object as parameter
fmgr.RegisterRuleAction(std.MarkResourceAsImportantActionName, std.MarkResourceAsImportantActionNameDeep, new ImportantRuleAction());
fmgr.RegisterRuleAction(std.DeleteResourceActionName, std.DeleteResourceActionNameDeep, new DeleteResourceAction());
fmgr.RegisterRuleAction(std.DeleteResourcePermActionName, std.DeleteResourcePermActionNameDeep, new DeleteResourcePermanentlyAction());
fmgr.RegisterRuleAction(std.MarkResourceAsReadActionName, std.MarkResourceAsReadActionNameDeep, new MarkMessageAsReadAction());
fmgr.RegisterRuleAction(std.MarkResourceAsUnreadActionName, std.MarkResourceAsUnreadActionNameDeep, new MarkMessageAsUnreadAction());
fmgr.RegisterRuleAction(std.ShowDesktopAlertActionName, std.ShowDesktopAlertActionNameDeep, new BalloonNotificationAction());
fmgr.RegisterRuleAction(std.ShowAsPlainTextActionName, std.ShowAsPlainTextActionNameDeep, new ShowAsPlainTextAction());
fmgr.RegisterRuleActionTemplate(std.AssignCategoryActionName, std.AssignCategoryActionNameDeep,
new AssignCategoryAction(), ConditionOp.In, "Category");
fmgr.RegisterRuleActionTemplate(std.AssignCategoryToAuthorActionName, std.AssignCategoryToAuthorActionNameDeep,
new AssignCategoryToMessageAuthorAction(), ConditionOp.In, "Category");
fmgr.RegisterRuleActionTemplate(std.PlaySoundFromFileActionName, std.PlaySoundFromFileActionNameDeep,
new PlaySoundAction(), ConditionOp.In, "ExternalFile", "Sound files (*.wav)|*.wav|All files(*.*)|*.*");
fmgr.RegisterRuleActionTemplate(std.DisplayMessageBoxActionName, std.DisplayMessageBoxActionNameDeep,
new MessageBoxNotificationAction(), ConditionOp.Eq);
fmgr.RegisterRuleActionTemplate(std.RunApplicationActionName, std.RunApplicationActionNameDeep,
new RunApplicationAction(), ConditionOp.In, "ExternalFile", "Execution files (*.exe)|*.exe|All files(*.*)|*.*");
res = fmgr.RegisterRuleActionTemplate(std.MarkMessageWithFlagActionName, std.MarkMessageWithFlagActionNameDeep,
new MarkMessageWithFlagAction(), ConditionOp.In, "Flag");
fmgr.MarkActionTemplateAsSingleSelection(res);
Core.ActionManager.RegisterLinkClickAction(new EditRuleAction(), FilterManagerProps.RuleResName, null);
}
public void RegisterFilters(IFilterRegistry filterRegistry)
{
ControllerActionFilterCriteria listActionsCriteria = new ControllerActionFilterCriteria();
listActionsCriteria.AddMethod <SearchController>(p => p.List(null, 0, null));
filterRegistry.Add(new[] { listActionsCriteria }, typeof(PageSizeActionFilter));
}
public void RegisterViewsEachRun()
{
IFilterRegistry fMgr = Core.FilterRegistry;
INotificationManager notifMgr = Core.NotificationManager;
string[] _applTypes = new string[] { NntpPlugin._newsArticle };
// Conditions/Templates necessary for notification rules.
IResource template = fMgr.CreateConditionTemplate(AppearedInNewsgroupName, AppearedInNewsgroupDeep,
_applTypes, ConditionOp.In, NntpPlugin._newsGroup, "Newsgroups");
fMgr.AssociateConditionWithGroup(template, "News Conditions");
IResource threadTemplate = fMgr.CreateConditionTemplate(AppearedInThreadName, AppearedInThreadDeep,
_applTypes, ConditionOp.In, NntpPlugin._newsArticle, "Reply*");
fMgr.AssociateConditionWithGroup(threadTemplate, "News Conditions");
IResource res = fMgr.RegisterCustomCondition(PostInMyThreadName, PostInMyThreadDeep, _applTypes, new RepliesToMyPosts());
fMgr.AssociateConditionWithGroup(res, "News Conditions");
res = fMgr.RegisterCustomCondition(PostInFlaggedThreadName, PostInFlaggedThreadDeep, _applTypes, new RepliesToFlaggedPosts());
fMgr.AssociateConditionWithGroup(res, "News Conditions");
// Notifications
notifMgr.RegisterNotifyMeResourceType(NntpPlugin._newsGroup, NntpPlugin._newsArticle);
notifMgr.RegisterNotifyMeCondition(NntpPlugin._newsArticle, fMgr.Std.FromContactX, Core.ResourceStore.GetPropId("From"));
notifMgr.RegisterNotifyMeCondition(NntpPlugin._newsGroup, template, 0);
notifMgr.RegisterNotifyMeCondition(NntpPlugin._newsArticle, threadTemplate, 0);
Core.FilterEngine.RegisterRuleApplicableResourceType(NntpPlugin._newsArticle);
}
public void RegisterViewsFirstRun()
{
string[] applType = new string[1] {
"Contact"
};
IResource res;
IFilterRegistry fMgr = Core.FilterRegistry;
// Conditions/Templates
res = fMgr.CreateConditionTemplate(ContactInABName, ContactInABNameDeep, applType, ConditionOp.In, "AddressBook", "InAddressBook");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateStandardCondition(ContactNotInABName, ContactNotInABNameDeep, applType, "InAddressBook", ConditionOp.HasNoProp);
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateConditionTemplate(LastCorrespondenceName, LastCorrespondenceNameDeep, applType, ConditionOp.Eq, "LastCorrespondDate");
fMgr.AssociateConditionWithGroup(res, "Temporal Conditions");
IResource condActive = FilterConvertors.InstantiateTemplate(res, "last 30 days", null);
// Views
IResource viewAll = fMgr.RegisterView("All", applType, (IResource[])null, null);
IResource viewActive = fMgr.RegisterView("Active", applType, new IResource[1] {
condActive
}, null);
viewAll.SetProp("DefaultSort", "LastName FirstName");
viewActive.SetProp("DefaultSort", "LastName FirstName");
Core.ResourceTreeManager.LinkToResourceRoot(viewAll, 10);
Core.ResourceTreeManager.LinkToResourceRoot(viewActive, 11);
viewAll.SetProp("DisableDefaultGroupping", true);
viewActive.SetProp("DisableDefaultGroupping", true);
}
public void RegisterViewsFirstRun()
{
IFilterRegistry mgr = Core.FilterRegistry;
IResource res = mgr.CreateStandardCondition(RSSViewsConstructor.PostIsACommentName, RSSViewsConstructor.PostIsACommentDeep,
new string[] { "RSSItem" }, "FeedComment", ConditionOp.HasLink);
mgr.AssociateConditionWithGroup(res, RSSViewsConstructor.RSSConditionsGroup);
}
public void RegisterViewsEachRun()
{
IFilterRegistry fMgr = Core.FilterRegistry;
IResource res = fMgr.CreateConditionTemplate(RSSViewsConstructor.FeedInFolderName, RSSViewsConstructor.FeedInFolderDeep,
null, ConditionOp.In, Props.RSSFeedGroupResource, "RssItem>Parent");
fMgr.AssociateConditionWithGroup(res, RSSViewsConstructor.RSSConditionsGroup);
}
/// <summary>
/// Registers the specified filter for the given controller action.
/// </summary>
/// <typeparam name="TController">The type of the controller.</typeparam>
/// <typeparam name="TFilter">The type of the filter.</typeparam>
/// <param name="instance">The instance.</param>
/// <param name="action">The controller action method.</param>
/// <returns></returns>
public static IFilterRegistry Register <TController, TFilter>(this IFilterRegistry instance, Expression <Action <TController> > action)
where TController : Controller
where TFilter : IMvcFilter
{
Invariant.IsNotNull(instance, "instance");
return(Register <TController, TFilter>(instance, action, filter => { }));
}
/// <summary>
/// Registers the specified filters for the given controller action.
/// </summary>
/// <typeparam name="TController">The type of the controller.</typeparam>
/// <typeparam name="TFilter1">The type of the filter1.</typeparam>
/// <typeparam name="TFilter2">The type of the filter2.</typeparam>
/// <param name="instance">The instance.</param>
/// <param name="action">The controller action method.</param>
/// <returns></returns>
public static IFilterRegistry Register <TController, TFilter1, TFilter2>(this IFilterRegistry instance, Expression <Action <TController> > action)
where TController : Controller
where TFilter1 : IMvcFilter
where TFilter2 : IMvcFilter
{
Invariant.IsNotNull(instance, "instance");
return(instance.Register(action, CreateFilterFactories(instance, typeof(TFilter1), typeof(TFilter2)).ToArray()));
}
/// <summary>
/// Registers the specified filters for the given controller.
/// </summary>
/// <typeparam name="TController">The type of the controller.</typeparam>
/// <typeparam name="TFilter1">The type of the filter1.</typeparam>
/// <typeparam name="TFilter2">The type of the filter2.</typeparam>
/// <param name="instance">The instance.</param>
/// <returns></returns>
public static IFilterRegistry Register <TController, TFilter1, TFilter2>([NotNull] this IFilterRegistry instance)
where TController : Controller
where TFilter1 : IMvcFilter
where TFilter2 : IMvcFilter
{
Invariant.IsNotNull(instance, "instance");
return(instance.Register <TController, IMvcFilter>(CreateFilterFactories(instance, typeof(TFilter1), typeof(TFilter2)).ToArray()));
}
public void RegisterFilters(IFilterRegistry filterRegistry)
{
ControllerActionFilterCriteria criteria = new ControllerActionFilterCriteria();
criteria.AddMethod <UserController>(u => u.ChangePassword(null));
criteria.AddMethod <UserController>(u => u.ChangePasswordSave(null, null));
filterRegistry.Add(new[] { criteria }, typeof(AuthorizationFilter));
}
public void RegisterFilters(IFilterRegistry filterRegistry)
{
ControllerActionFilterCriteria ajaxActionCriteria = new ControllerActionFilterCriteria();
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.List(null));
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.ListByEvent(null, null));
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.ListByEventAndTag(null, null, null));
filterRegistry.Add(new[] { ajaxActionCriteria }, typeof(AjaxActionFilter));
}
/// <summary>
/// Registers the specified filters for the given controller types.
/// </summary>
/// <typeparam name="TFilter1">The type of the filter1.</typeparam>
/// <typeparam name="TFilter2">The type of the filter2.</typeparam>
/// <param name="instance">The instance.</param>
/// <param name="typeCatalog">The controller types.</param>
/// <returns></returns>
public static IFilterRegistry Register <TFilter1, TFilter2>(this IFilterRegistry instance, TypeCatalog typeCatalog)
where TFilter1 : IMvcFilter
where TFilter2 : IMvcFilter
{
Invariant.IsNotNull(instance, "instance");
Invariant.IsNotNull(typeCatalog, "typeCatalog");
return(Register(instance, typeCatalog, typeof(TFilter1), typeof(TFilter2)));
}
public MockPluginEnvironment(IResourceStore storage)
{
_picoContainer = new DefaultPicoContainer();
_mockPicoContainer = new DefaultPicoContainer(_picoContainer);
Storage = storage;
if (storage != null)
{
_picoContainer.RegisterComponentInstance(storage);
}
File.Delete(".\\MockPluginEnvironment.ini");
_settingStore = new Ini.IniFile(".\\MockPluginEnvironment.ini");
DynamicMock actionManagerMock = new DynamicMock(typeof(IActionManager));
actionManagerMock.SetupResult("GetKeyboardShortcut", "", typeof(IAction));
_actionManager = (IActionManager)actionManagerMock.MockInstance;
_uiManager = (IUIManager) new DynamicMock(typeof(IUIManager)).MockInstance;
_pluginLoader = (IPluginLoader) new DynamicMock(typeof(IPluginLoader)).MockInstance;
_resourceBrowser = (IResourceBrowser) new DynamicMock(typeof(IResourceBrowser)).MockInstance;
_tabManager = new MockTabManager();
_resourceAP = new MockAsyncProcessor();
_networkAP = new MockAsyncProcessor();
_uiAP = new MockAsyncProcessor();
DynamicMock resourceIconManagerMock = new DynamicMock(typeof(IResourceIconManager));
resourceIconManagerMock.SetupResult("IconColorDepth", ColorDepth.Depth8Bit);
resourceIconManagerMock.SetupResult("GetIconIndex", 0, typeof(IResource));
_resourceIconManager = (IResourceIconManager)resourceIconManagerMock.MockInstance;
_notificationManager = (INotificationManager) new DynamicMock(typeof(INotificationManager)).MockInstance;
_textIndexManager = (ITextIndexManager) new DynamicMock(typeof(ITextIndexManager)).MockInstance;
_messageFormatter = (IMessageFormatter) new DynamicMock(typeof(IMessageFormatter)).MockInstance;
_displayColumnManager = (IDisplayColumnManager) new DynamicMock(typeof(IDisplayColumnManager)).MockInstance;
// DynamicMock filterManagerMock = new DynamicMock( typeof(IFilterRegistry) );
DynamicMock filterEngineMock = new DynamicMock(typeof(IFilterEngine));
filterEngineMock.SetupResult("ExecRules", true, typeof(string), typeof(IResource));
DynamicMock filterManagerMock = new DynamicMock(typeof(IFilterRegistry));
_filterRegistry = (IFilterRegistry)filterManagerMock.MockInstance;
_rcManager = (IRemoteControlManager) new DynamicMock(typeof(IRemoteControlManager)).MockInstance;
_trayIconManager = (ITrayIconManager) new DynamicMock(typeof(ITrayIconManager)).MockInstance;
_formattingRuleManager = (IFormattingRuleManager) new DynamicMock(typeof(IFormattingRuleManager)).MockInstance;
_expirationRuleManager = (IExpirationRuleManager) new DynamicMock(typeof(IExpirationRuleManager)).MockInstance;
_filteringFormsManager = (IFilteringFormsManager) new DynamicMock(typeof(IFilteringFormsManager)).MockInstance;
_searchQueryExtensions = (ISearchQueryExtensions) new DynamicMock(typeof(ISearchQueryExtensions)).MockInstance;
_filterEngine = (IFilterEngine) new DynamicMock(typeof(IFilterEngine)).MockInstance;
theInstance = this;
}
/// <summary>
/// Registers and configures the specified filter for the given controller action.
/// </summary>
/// <typeparam name="TController">The type of the controller.</typeparam>
/// <typeparam name="TFilter">The type of the filter.</typeparam>
/// <param name="instance">The instance.</param>
/// <param name="action">The controller action method.</param>
/// <param name="configureFilter">The configure filter.</param>
/// <returns></returns>
public static IFilterRegistry Register <TController, TFilter>(this IFilterRegistry instance, Expression <Action <TController> > action, Action <TFilter> configureFilter)
where TController : Controller
where TFilter : IMvcFilter
{
Invariant.IsNotNull(instance, "instance");
Invariant.IsNotNull(action, "action");
Invariant.IsNotNull(configureFilter, "configureFilter");
return(instance.Register(action, CreateAndConfigureFilterFactory(instance, configureFilter)));
}
private static void RegisterCustomConditions()
{
IResource res;
IFilterRegistry fMgr = Core.FilterRegistry;
#region Core.FilterRegistry.Std.ResourceIsCategorized Cleaning
// Fix previous version of this condition (it was implemented as
// predicate-type).
IResourceList old = Core.ResourceStore.FindResources(FilterManagerProps.ConditionResName, "Name", Core.FilterRegistry.Std.ResourceIsCategorizedName);
old = old.Intersect(Core.ResourceStore.FindResources(FilterManagerProps.ConditionResName, "ConditionType", "predicate"), true);
old.DeleteAll();
#endregion Core.FilterRegistry.Std.ResourceIsCategorized Cleaning
fMgr.RegisterCustomCondition(fMgr.Std.ResourceIsCategorizedName, fMgr.Std.ResourceIsCategorizedNameDeep,
null, new ResourceIsCategorized());
res = fMgr.RegisterCustomCondition(fMgr.Std.ResourceHasEmptyContentName, fMgr.Std.ResourceHasEmptyContentNameDeep,
null, new ResourceHasEmptyContent());
fMgr.MarkConditionOnlyForRule(res);
res = fMgr.CreateStandardCondition(FilterManagerStandards.DummyConditionName, FilterManagerStandards.DummyConditionName,
null, "Id", ConditionOp.Gt, "0");
res.SetProp("Invisible", true);
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.InTheCategoryAndSubcategoriesXName, fMgr.Std.InTheCategoryAndSubcategoriesXNameDeep,
null, new MatchCategoryAndSubcategories(), ConditionOp.In, "Category", "Category");
fMgr.AssociateConditionWithGroup(res, "Category Conditions");
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.FromToCCContactXName, fMgr.Std.FromToCCContactXNameDeep,
null, new CorrespondenceOfContact(), ConditionOp.In, "Contact", "Category");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.FromToContactXName, fMgr.Std.FromToContactXNameDeep,
null, new FromToOfContact(), ConditionOp.In, "Contact", "Category");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.ResourceContainsTextXName, fMgr.Std.ResourceContainsTextXNameDeep,
null, new ResourceContainsText(), ConditionOp.Eq, "Subject");
fMgr.AssociateConditionWithGroup(res, "Text Query Conditions");
fMgr.MarkConditionOnlyForRule(res);
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.MessageIsInThreadOfXName, fMgr.Std.MessageIsInThreadOfXNameDeep,
null, new MessageIsInThreadOf(), ConditionOp.In, "Email", "Category");
res.SetProp("Invisible", true);
// Interversion consistency. In old build this condition was
// registered in other plugin(s). Since they now refer to Std,
// we have to register it again.
res = fMgr.CreateConditionTemplate(fMgr.Std.FromContactXName, fMgr.Std.FromContactXNameDeep, null, ConditionOp.In, "Contact", "From");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
// Upgrade for old versions.
res = fMgr.CreateConditionTemplate(fMgr.Std.DeletedInTheTimeSpanXName, fMgr.Std.DeletedInTheTimeSpanXNameDeep, null, ConditionOp.Eq, "DelDate");
fMgr.AssociateConditionWithGroup(res, "Temporal Conditions");
}
public static IFilterRegistry Register <TController, TFilter>([NotNull] this IFilterRegistry instance, [NotNull] Action <TFilter> configureFilter)
where TController : Controller
where TFilter : IMvcFilter
{
Invariant.IsNotNull(instance, "instance");
Invariant.IsNotNull(configureFilter, "configureFilter");
instance.Register <TController, IMvcFilter>(CreateAndConfigureFilterFactory(instance, configureFilter));
return(instance);
}
public void RegisterViewsFirstRun()
{
IResource res;
IFilterRegistry fMgr = Core.FilterRegistry;
// Conditions/Templates
IResource myResType = Core.ResourceStore.FindUniqueResource("ResourceType", "Name", NntpPlugin._newsArticle);
res = fMgr.CreateStandardCondition(AuthorPostedArticleName, AuthorPostedArticleDeep, new string[] { "Contact" },
"LinkedResourcesOfType", ConditionOp.In, myResType.ToResourceList());
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
}
void IViewsConstructor.RegisterViewsFirstRun()
{
IResource res;
IFilterRegistry fMgr = Core.FilterRegistry;
// Conditions/Templates
IResource myResType = Core.ResourceStore.FindUniqueResource("ResourceType", Core.Props.Name, STR.Email);
res = fMgr.CreateStandardCondition(OutlookViewsInitializer.AuthorPostedMailName, OutlookViewsInitializer.AuthorPostedMailDeep,
new string[] { "Contact" }, "LinkedResourcesOfType", ConditionOp.In, myResType.ToResourceList());
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
}
public void RegisterFilters(IFilterRegistry filterRegistry)
{
filterRegistry.Add(Enumerable.Empty <IFilterCriteria>(), typeof(PluginTemplateFilter));
ControllerActionFilterCriteria ajaxActionCriteria = new ControllerActionFilterCriteria();
ajaxActionCriteria.AddMethod <PluginController>(p => p.List(null));
ajaxActionCriteria.AddMethod <PluginController>(p => p.RefreshListNotInstalled());
ajaxActionCriteria.AddMethod <PluginController>(p => p.SetEnabled(null, false, null, null));
ajaxActionCriteria.AddMethod <PluginController>(p => p.Install(null, null));
ajaxActionCriteria.AddMethod <PluginController>(p => p.Uninstall(null, null));
filterRegistry.Add(new[] { ajaxActionCriteria }, typeof(AjaxActionFilter));
}
private static IFilterRegistry Register(IFilterRegistry instance, IEnumerable <Type> typeCatalog, params Type[] filterTypes)
{
IList <Type> controllerTypes = typeCatalog.ToList();
EnsureControllerTypes(controllerTypes);
foreach (Type itemType in controllerTypes.Select(controllerType => genericControllerItemType.MakeGenericType(controllerType)))
{
instance.Items.Add(Activator.CreateInstance(itemType, new object[] { CreateFilterFactories(instance, filterTypes) }) as FilterRegistryItem);
}
return(instance);
}
public void RegisterFilters(IFilterRegistry filterRegistry)
{
filterRegistry.Add(new[] { new DataFormatFilterCriteria("SIGN") }, typeof(SignResultActionFilter));
filterRegistry.Add(new[] { new DataFormatFilterCriteria("ICS") }, typeof(IcsResultActionFilter));
ControllerActionFilterCriteria ajaxActionCriteria = new ControllerActionFilterCriteria();
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.List(null));
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.ListByEvent(null, null));
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.ListByUser(null, null));
ajaxActionCriteria.AddMethod <ScheduleItemController>(si => si.ListByEventAndTag(null, null, null));
filterRegistry.Add(new[] { ajaxActionCriteria }, typeof(AjaxActionFilter));
}
/// <summary>
/// Method is called when a plugin that implements this interface is loaded first time.
/// </summary>
public void RegisterViewsFirstRun()
{
IResource res;
string[] applType = new string[] { "RSSItem" }, contactType = new string[] { "Contact" };
IFilterRegistry fMgr = Core.FilterRegistry;
IResource myResType = Core.ResourceStore.FindUniqueResource("ResourceType", "Name", "RSSItem");
res = fMgr.CreateStandardCondition(AuthorWrotePostName, AuthorWrotePostDeep, contactType,
"LinkedResourcesOfType", ConditionOp.In, myResType.ToResourceList());
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateStandardCondition(AuthorHasFeedName, AuthorHasFeedDeep, contactType, "Weblog", ConditionOp.HasLink);
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateStandardCondition(PostHasEnclosuredName, PostHasEnclosuredDeep, applType, "EnclosureURL", ConditionOp.HasProp);
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateStandardCondition(PostHasCommentName, PostHasCommentDeep, applType, "CommentCount", ConditionOp.Gt, "0");
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateStandardCondition(PostIsACommentName, PostIsACommentDeep, applType, "FeedComment", ConditionOp.HasLink);
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateStandardCondition(DownloadFailedName, DownloadFailedDeep, applType,
"EnclosureDownloadingState", ConditionOp.In, "3");
fMgr.RenameCondition("Enclosure downloading failed", "Enclosure downloading is failed");
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateStandardCondition(DownloadCompletedName, DownloadCompletedDeep, applType,
"EnclosureDownloadingState", ConditionOp.In, "2");
fMgr.RenameCondition("Enclosure downloading completed", "Enclosure downloading is completed");
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateStandardCondition(DownloadNotName, DownloadNotDeep, applType,
"EnclosureDownloadingState", ConditionOp.In, "0");
fMgr.RenameCondition("Enclosure not downloaded", "Enclosure is not downloaded");
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateStandardCondition(DownloadPlannedName, DownloadPlannedDeep, applType,
"EnclosureDownloadingState", ConditionOp.In, "1", "4");
fMgr.RenameCondition("Enclosure downloading planned", "Enclosure downloading is planned");
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateConditionTemplate(EnclosureSizeName, EnclosureSizeDeep, applType,
ConditionOp.InRange, "EnclosureSize", "0", Int32.MaxValue.ToString());
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
res = fMgr.CreateConditionTemplate(EnclosureTypeName, EnclosureTypeDeep, applType, ConditionOp.Eq, "EnclosureType");
fMgr.AssociateConditionWithGroup(res, RSSConditionsGroup);
}
private static void RegisterViews()
{
IFilterRegistry fMgr = Core.FilterRegistry;
if (Core.ResourceStore.FindResources(FilterManagerProps.ViewResName, "DeepName", "Deleted Resources").Count == 0)
{
Trace.WriteLine("ViewsInitializer -- DeletedResources view is not found");
IResource res = fMgr.RegisterView("Deleted Resources", new [] { fMgr.Std.ResourceIsDeleted }, null);
fMgr.AssociateViewWithFolder(res, null, 3);
fMgr.SetVisibleInAllTabs(res);
res.SetProp(Core.Props.ShowDeletedItems, true);
res.SetProp("IsLiveMode", true);
}
}
public void RegisterFilters(IFilterRegistry registry)
{
registry.Add(Enumerable.Empty <IFilterCriteria>(), typeof(AreaListActionFilter));
registry.Add(Enumerable.Empty <IFilterCriteria>(), typeof(TagCloudActionFilter));
registry.Add(Enumerable.Empty <IFilterCriteria>(), typeof(SidebarActionFilter));
ControllerActionFilterCriteria itemActionCriteria = new ControllerActionFilterCriteria();
itemActionCriteria.AddMethod <PostController>(p => p.Item(null));
itemActionCriteria.AddMethod <PostController>(p => p.AddComment(null, null, null, null, null, null));
registry.Add(new[] { itemActionCriteria }, typeof(PostWebViewBugResultFilter));
ControllerActionFilterCriteria listActionCriteria = new ControllerActionFilterCriteria();
listActionCriteria.AddMethod <PostController>(p => p.List(null, 0, null));
listActionCriteria.AddMethod <PostController>(p => p.ListByArchive(0, null));
listActionCriteria.AddMethod <PostController>(p => p.ListByArea(null, 0, null, null));
listActionCriteria.AddMethod <PostController>(p => p.ListBySearch(null, 0, null, null));
listActionCriteria.AddMethod <PostController>(p => p.ListByTag(null, 0, null, null));
registry.Add(new IFilterCriteria[] { listActionCriteria, new DataFormatFilterCriteria("RSS") }, typeof(PostRssViewBugResultFilter));
registry.Add(new IFilterCriteria[] { listActionCriteria, new DataFormatFilterCriteria("ATOM") }, typeof(PostAtomViewBugResultFilter));
ControllerActionFilterCriteria listActionsCriteria = new ControllerActionFilterCriteria();
listActionsCriteria.AddMethod <PostController>(p => p.List(null, 0, null));
listActionsCriteria.AddMethod <PostController>(p => p.ListByArchive(0, null));
listActionsCriteria.AddMethod <PostController>(p => p.ListByArea(null, 0, null, null));
listActionsCriteria.AddMethod <PostController>(p => p.ListByAreaAndTag(null, 0, null, null, null));
listActionsCriteria.AddMethod <PostController>(p => p.ListBySearch(null, 0, null, null));
listActionsCriteria.AddMethod <PostController>(p => p.ListByTag(null, 0, null, null));
listActionsCriteria.AddMethod <PostController>(p => p.ListWithDrafts(null, 0));
registry.Add(new[] { listActionsCriteria }, typeof(MIXVideos.Oxite.Filters.PageSizeActionFilter));
ControllerActionFilterCriteria outputCacheCriteria = new ControllerActionFilterCriteria();
outputCacheCriteria.AddMethod <PostController>(c => c.List(null, 0, null));
outputCacheCriteria.AddMethod <PostController>(c => c.ListByArchive(0, null));
outputCacheCriteria.AddMethod <PostController>(c => c.ListByArea(null, 0, null, null));
outputCacheCriteria.AddMethod <PostController>(c => c.ListBySearch(null, 0, null, null));
outputCacheCriteria.AddMethod <PostController>(c => c.ListByTag(null, 0, null, null));
outputCacheCriteria.AddMethod <TagController>(c => c.Cloud());
outputCacheCriteria.AddMethod <TagController>(c => c.CloudForArea(null));
registry.Add(new[] { outputCacheCriteria }, typeof(OneHourOutputCacheFilter));
ControllerActionFilterCriteria fileFeedActionCriteria = new ControllerActionFilterCriteria();
fileFeedActionCriteria.AddMethod <FeedController>(f => f.List(null));
registry.Add(new IFilterCriteria[] { fileFeedActionCriteria, new DataFormatFilterCriteria("RSS") }, typeof(PostRssViewBugResultFilter));
}
public void Execute(IDictionary <string, object> state)
{
IModulesLoaded modulesLoaded = container.Resolve <IModulesLoaded>();
RouteCollection routes = container.Resolve <RouteCollection>();
IFilterRegistry filterRegistry = container.Resolve <FilterRegistry>();
ModelBinderDictionary modelBinders = container.Resolve <ModelBinderDictionary>();
filterRegistry.Clear();
modelBinders.Clear();
//todo: (nheskew) get plugin routes registered on load in the right order instead of just clearing the routes before module init
routes.Clear();
foreach (Module module in container.Resolve <IModuleService>().GetModules())
{
IOxiteModule moduleInstance = modulesLoaded.Load(module);
if (moduleInstance != null)
{
moduleInstance.RegisterWithContainer();
moduleInstance.Initialize();
moduleInstance.RegisterFilters(filterRegistry);
moduleInstance.RegisterModelBinders(modelBinders);
container.RegisterInstance(modulesLoaded);
}
}
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.LoadFromModules(modulesLoaded);
routes.LoadCatchAllFromModules(modulesLoaded);
container.RegisterInstance(filterRegistry);
////TODO: (erikpo) Rename IOxiteModule to IOxiteBackgroundService
//IModuleRegistry moduleRegistry = container.Resolve<ModuleRegistry>();
//moduleRegistry.Clear();
//container.Resolve<IRegisterModules>().RegisterModules(moduleRegistry);
//foreach (IOxiteModule module in moduleRegistry.GetModules())
// module.Start();
//container.RegisterInstance(moduleRegistry);
}
public RegisterFilters(IFilterRegistry filterRegistry)
: base(filterRegistry)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterRegistry"/> class.
/// </summary>
/// <param name="filterRegistry">The filter registry</param>
public FilterProvider(IFilterRegistry filterRegistry)
{
this.filterRegistry = filterRegistry;
}
/// <summary>
/// Initializes a new instance of the <see cref="RegisterFiltersBase"/> class.
/// </summary>
/// <param name="filterRegistry">The filter registry.</param>
protected RegisterFiltersBase(IFilterRegistry filterRegistry)
{
Invariant.IsNotNull(filterRegistry, "filterRegistry");
FilterRegistry = filterRegistry;
}
public RegisterFiltersBaseTestDouble(IFilterRegistry filterRegistry)
: base(filterRegistry)
{
}
public ConfigureFilters(IFilterRegistry registry)
: base(registry)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigureFiltersBase"/> class.
/// </summary>
/// <param name="registry">The registry.</param>
protected ConfigureFiltersBase(IFilterRegistry registry)
{
Invariant.IsNotNull(registry, "registry");
Registry = registry;
}
public ExtendedControllerActionInvokerTestDouble(IServiceLocator locator, IFilterRegistry filterRegistry)
: base(locator, filterRegistry)
{
}
public ConfigureFiltersBaseTestDouble(IFilterRegistry registry)
: base(registry)
{
}
