private void ProcessPlacementFile(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor, PlacementFile placementFile) {
var feature = new Feature { Descriptor = featureDescriptor };
// invert the tree into a list of leaves and the stack
var entries = DrillDownShapeLocations(placementFile.Nodes, Enumerable.Empty<PlacementMatch>());
foreach (var entry in entries) {
var shapeLocation = entry.Item1;
var matches = entry.Item2;
string shapeType;
string differentiator;
GetShapeType(shapeLocation, out shapeType, out differentiator);
Func<ShapePlacementContext, bool> predicate = ctx => true;
if (differentiator != "") {
predicate = ctx => (ctx.Differentiator ?? "") == differentiator;
}
if (matches.Any()) {
predicate = matches.SelectMany(match => match.Terms).Aggregate(predicate, BuildPredicate);
}
var placement = new PlacementInfo();
var segments = shapeLocation.Location.Split(';').Select(s => s.Trim());
foreach (var segment in segments) {
if (!segment.Contains('=')) {
placement.Location = segment;
}
else {
var index = segment.IndexOf('=');
var property = segment.Substring(0, index).ToLower();
var value = segment.Substring(index + 1);
switch (property) {
case "shape":
placement.ShapeType = value;
break;
case "alternate":
placement.Alternates = new[] { value };
break;
case "wrapper":
placement.Wrappers = new[] { value };
break;
}
}
}
builder.Describe(shapeType)
.From(feature)
.Placement(ctx => {
var hit = predicate(ctx);
// generate 'debugging' information to trace which file originated the actual location
if (hit) {
var virtualPath = featureDescriptor.Extension.Location + "/" + featureDescriptor.Extension.Id + "/Placement.info";
ctx.Source = virtualPath;
}
return hit;
}, placement);
}
}
public void Enabled(Feature feature)
{
const string taxonomyName = "Package Types";
var taxonomy = _taxonomyService.GetTaxonomyByName(taxonomyName);
if (taxonomy != null) {
var moduleTerm = _taxonomyService.GetTermByName(taxonomy.Id, "Module");
if (moduleTerm == null) {
moduleTerm = _taxonomyService.NewTerm(taxonomy);
moduleTerm.Name = "Module";
moduleTerm.Slug = "Modules";
moduleTerm.Container = taxonomy.ContentItem;
_services.ContentManager.Create(moduleTerm, VersionOptions.Published);
}
var themeTerm = _taxonomyService.GetTermByName(taxonomy.Id, "Theme");
if (themeTerm == null) {
themeTerm = _taxonomyService.NewTerm(taxonomy);
themeTerm.Name = "Theme";
themeTerm.Slug = "Themes";
themeTerm.Container = taxonomy.ContentItem;
_services.ContentManager.Create(themeTerm, VersionOptions.Published);
}
}
}
public void Uninstalled(Feature feature)
{
var featureName = feature.Descriptor.Id;
if (_dataMigrationManager.IsFeatureAlreadyInstalled(featureName))
{
_dataMigrationManager.Uninstall(featureName);
}
}
public void Enabled(Feature feature)
{
if (feature.Descriptor.Id != "Szmyd.Orchard.Modules.Menu") return;
var currentMainMenu = _menuService.GetMenu("main");
if (currentMainMenu == null)
{
_services.ContentManager.Create<AdvancedMenuPart>("Menu", p => p.Name = "main");
}
var currentItems = _menuService.GetMenuItems("main");
/* Creating new menu with Home in it */
if (!currentItems.Any())
{
_services.ContentManager.Create<AdvancedMenuItemPart>("SimpleMenuItem",
nItem =>
{
nItem.DisplayHref = true;
nItem.DisplayText = true;
nItem.MenuName = "main";
nItem.Url = "/";
nItem.Position = "0";
nItem.Text = "Home";
});
}
// Adding the default menu widget to Navigation zone in Default layer
var layerPart = _widgets.GetLayers().FirstOrDefault(l => l.Name == "Default");
if (layerPart == null)
{
return;
}
var countDefault = _services.ContentManager
.Query<WidgetPart, WidgetPartRecord>()
.Where(p => p.Zone == "Navigation")
.ForType("MenuWidget").List();
if (countDefault.Count() == 0)
{
_services.ContentManager.Create<WidgetPart>("StyledMenuWidget",
widget =>
{
widget.Record.Title = "Main menu";
widget.Record.Position = "0";
widget.Record.Zone = "Navigation";
widget.LayerPart = layerPart;
widget.As<MenuWidgetPart>().Levels = 0;
widget.As<MenuWidgetPart>().CutOrFlattenLower = false;
widget.As<MenuWidgetPart>().MenuName = "main";
widget.As<MenuWidgetPart>().WrapChildrenInDiv = false;
widget.As<MenuWidgetPart>().Mode = MenuWidgetMode.AllItems;
widget.As<MenuStylingPart>().BackColor = "#FFFFFF";
widget.As<MenuStylingPart>().ForeColor = "#333333";
widget.As<MenuStylingPart>().HoverBackColor = "#F7F7F7";
widget.As<MenuStylingPart>().HoverForeColor = "#444444";
widget.As<MenuStylingPart>().SelectedForeColor = "#333333";
widget.As<MenuStylingPart>().SelectedBackColor = "#F1F1F1";
widget.As<MenuStylingPart>().Style = MenuStyles.SuperfishHorizontal;
});
}
}
public void Disabled(Feature feature) {
var currentTheme = _siteThemeService.GetCurrentThemeName();
if (feature.Descriptor.Name == currentTheme) {
_siteThemeService.SetSiteTheme(null);
// Notifications don't work in feature events. See: https://github.com/OrchardCMS/Orchard/issues/6106
_notifier.Warning(T("The current theme was disabled, because one of its dependencies was disabled."));
}
}
public void Enabled(Feature feature)
{
CreateTaxonomy("FeatureCategory", new List<string> {
"Operations",
"Accounting",
"Accessibility",
"Sales"
});
}
public void AddDefaultTagsForFeature(Feature feature)
{
var featureName = feature.Descriptor.Id;
if (!featureName.Equals(Constants.LocalArea, StringComparison.OrdinalIgnoreCase))
return;
var taxonomy = _taxonomyService.GetTaxonomyByName(Constants.Taxonomies.Tags);
_taxonomyImportService.CreateTermFor(taxonomy, "Question", null);
}
public ShapeAlterationBuilder(Feature feature, string shapeType) {
_feature = feature;
_bindingName = shapeType;
var delimiterIndex = shapeType.IndexOf("__");
if (delimiterIndex < 0) {
_shapeType = shapeType;
}
else {
_shapeType = shapeType.Substring(0, delimiterIndex);
}
}
public void AddDefaultCategoriesForFeature(Feature feature)
{
var featureName = feature.Descriptor.Id;
if (!featureName.Equals(Constants.LocalArea, StringComparison.OrdinalIgnoreCase))
return;
var taxonomy = _taxonomyService.GetTaxonomyByName(Constants.Taxonomies.Categories);
_taxonomyImportService.CreateTermFor(taxonomy, "Administration", null);
_taxonomyImportService.CreateTermFor(taxonomy, "Announcements", null);
_taxonomyImportService.CreateTermFor(taxonomy, "General", null);
}
public void Enabled(Feature feature)
{
//var taxonomyList = new List<string> {
// "Remodel",
// "Construction",
// "Repair"
//};
}
public void Enabled(Feature feature) {
if (feature.Descriptor.Id != "NGM.CasClient")
return;
var settings = _orchardServices.WorkContext.CurrentSite.As<CASSettingsPart>();
settings.ProcessIncomingSingleSignOutRequests = true;
settings.ProxyCallbackParameterName = "proxyResponse";
settings.GatewayParameterName = "gatewayResponse";
settings.ArtifactParameterName = "ticket";
settings.GatewayStatusCookieName = "cas_gateway_status";
settings.TicketValidatorName = "Saml11";
settings.ServiceTicketManager = "CacheServiceTicketManager";
settings.ProxyTicketManager = "CacheProxyTicketManager";
settings.TicketTimeTolerance = 5000;
}
public void AddDefaultRolesForFeature(Feature feature) {
var featureName = feature.Descriptor.Id;
// when another module is being enabled, locate matching permission providers
var providersForEnabledModule = _permissionProviders.Where(x => x.Feature.Descriptor.Id == featureName);
if (providersForEnabledModule.Any()) {
Logger.Debug("Configuring default roles for module {0}", featureName);
}
else {
Logger.Debug("No default roles for module {0}", featureName);
}
foreach (var permissionProvider in providersForEnabledModule) {
// get and iterate stereotypical groups of permissions
var stereotypes = permissionProvider.GetDefaultStereotypes();
foreach (var stereotype in stereotypes) {
// turn those stereotypes into roles
var role = _roleService.GetRoleByName(stereotype.Name);
if (role == null) {
Logger.Information("Defining new role {0} for permission stereotype", stereotype.Name);
_roleService.CreateRole(stereotype.Name);
role = _roleService.GetRoleByName(stereotype.Name);
}
// and merge the stereotypical permissions into that role
var stereotypePermissionNames = (stereotype.Permissions ?? Enumerable.Empty<Permission>()).Select(x => x.Name);
var currentPermissionNames = role.RolesPermissions.Select(x => x.Permission.Name);
var distinctPermissionNames = currentPermissionNames
.Union(stereotypePermissionNames)
.Distinct();
// update role if set of permissions has increased
var additionalPermissionNames = distinctPermissionNames.Except(currentPermissionNames);
if (additionalPermissionNames.Any()) {
foreach (var permissionName in additionalPermissionNames) {
Logger.Information("Default role {0} granted permission {1}", stereotype.Name, permissionName);
_roleService.CreatePermissionForRole(role.Name, permissionName);
}
}
}
}
}
public void Enabled(Feature feature)
{
CreateTaxonomy("PropertyType", new List<string> {
"Single-Family Home",
"Apartment",
"Duplex",
"Triplex",
"Quadraplex",
"Townhouse",
"Detached House",
"Cottage",
"Cabin",
"Multi-Family Home",
"Villa",
"Zero-Lot-Line Home",
"Patio Home",
"Courtyard Home",
"Terraced House",
"Condominium",
"Timeshare/Interval Ownership",
"Housing Cooperative",
"Land Lease",
"Carriage Home/Coach Home",
"Mobile Home",
"Houseboat",
"Boxcar",
"Tent"
});
CreateTaxonomy("Ammenities", new List<string> {
"Air Conditioning",
"Washer and Dryer",
"Laundromat on Property",
"Dishwasher",
"On Site Security",
"Pets Allowed",
"Smoking Allowed",
"Fireplace",
"Walk In Closet",
"Hot Tub / Spa",
"Cable Tv",
"High Speed Internet",
"Community Grill",
"Covered Parking",
"Gated /Controlled Entrance",
"Bus/Public Transportation"
});
CreateTaxonomy("RentOrSale", new List<string> {"Rent","Sale"});
}
public void Enabled(Feature feature) {
//if genre taxonomy not defined - the ncreate
if(_taxonomyService.GetTaxonomyByName("Genre")==null) {
var genre= _contentManager.New<TaxonomyPart>("Taxonomy");
genre.Name = "Genre";
_contentManager.Create(genre, VersionOptions.Published);
CreateTerm(genre, "Action");
CreateTerm(genre, "Adventure");
CreateTerm(genre, "Animation");
CreateTerm(genre, "Comedy");
CreateTerm(genre, "Drama");
CreateTerm(genre, "Crime");
CreateTerm(genre, "Documentary");
}
}
public void Enabled(Feature feature) {
// if Genre taxonomy does not exist
// create Genre taxonomy
// create several genre terms in the taxonomy
if (_taxonomyService.GetTaxonomyByName("Genre") == null) {
var genre = _contentManager.New<TaxonomyPart>("Taxonomy");
genre.Name = "Genre";
_contentManager.Create(genre, VersionOptions.Published);
CreateTerm(genre, "Action");
CreateTerm(genre, "Adventure");
CreateTerm(genre, "Animation");
CreateTerm(genre, "Comedy");
CreateTerm(genre, "Crime");
CreateTerm(genre, "Documentary");
CreateTerm(genre, "Drama");
}
}
protected override void Register(ContainerBuilder builder) {
if (builder == null) {
throw new ArgumentNullException("builder");
}
builder.RegisterAutoMocking();
_testFeature = new Feature {
Descriptor = new FeatureDescriptor {
Id = "Testing",
Extension = new ExtensionDescriptor {
Id = "Testing",
ExtensionType = DefaultExtensionTypes.Module,
}
}
};
builder.RegisterType<ShapeAttributeBindingStrategy>().As<IShapeTableProvider>();
builder.RegisterInstance(new TestProvider()).WithMetadata("Feature", _testFeature);
builder.RegisterInstance(new RouteCollection());
builder.RegisterModule(new ShapeAttributeBindingModule());
}
public void Init() {
var testFeature = new Feature
{
Descriptor = new FeatureDescriptor
{
Id = "Testing",
Extension = new ExtensionDescriptor
{
Id = "Testing",
ExtensionType = DefaultExtensionTypes.Module,
}
}
};
var workContext = new DefaultDisplayManagerTests.TestWorkContext
{
CurrentTheme = new ExtensionDescriptor { Id = "Hello" }
};
var builder = new ContainerBuilder();
builder.RegisterModule(new ShapeAttributeBindingModule());
builder.RegisterType<ShapeAttributeBindingStrategy>().As<IShapeTableProvider>();
builder.RegisterType<ShapeTableLocator>().As<IShapeTableLocator>();
builder.RegisterType<DefaultDisplayManager>().As<IDisplayManager>();
builder.RegisterType<DefaultShapeFactory>().As<IShapeFactory>();
builder.RegisterType<DisplayHelperFactory>().As<IDisplayHelperFactory>();
builder.RegisterInstance(new Work<IEnumerable<IShapeTableEventHandler>>(resolve => _container.Resolve<IEnumerable<IShapeTableEventHandler>>())).AsSelf();
builder.RegisterType<DefaultShapeTableManager>().As<IShapeTableManager>();
builder.RegisterType<StubCacheManager>().As<ICacheManager>();
builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();
builder.RegisterInstance(new DefaultDisplayManagerTests.TestWorkContextAccessor(workContext)).As<IWorkContextAccessor>();
builder.RegisterInstance(new SimpleShapes()).WithMetadata("Feature", testFeature);
builder.RegisterInstance(new RouteCollection());
builder.RegisterAutoMocking(MockBehavior.Loose);
_container = builder.Build();
_container.Resolve<Mock<IOrchardHostContainer>>()
.Setup(x => x.Resolve<IComponentContext>())
.Returns(_container);
}
private void ProcessPlacementFile(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor, PlacementFile placementFile)
{
var feature = new Feature { Descriptor = featureDescriptor };
foreach (var entry in placementFile)
{
var shapeType = entry.Key;
var matches = entry.Value;
foreach (var filter in entry.Value)
{
var placement = new PlacementInfo();
placement.Location = filter.Location;
placement.Alternates = filter.Alternates;
placement.Wrappers = filter.Wrappers;
placement.ShapeType = filter.ShapeType;
builder.Describe(shapeType)
.From(feature)
.Placement(ctx => CheckFilter(ctx, filter), placement);
}
}
}
public void Installing(Feature feature)
{
}
public void Enabling(Feature feature)
{
}
public void Installed(Feature feature)
{
}
public void Disabling(Feature feature)
{
}
public void Enabled(Feature feature)
{
}
public void Disabled(Feature feature)
{
}
public void Uninstalled(Feature feature)
{
}
public ClientRouteAlteration(string routeName, Feature feature, IList<Action<ClientRouteDescriptor>> configurations) {
_configurations = configurations;
RouteName = routeName;
Feature = feature;
}
public void Installed(Feature feature) {
if (feature.Descriptor.Id == "Gallery") {
_packagingSourceManager.AddSource("Orchard Gallery", "http://orchardproject.net/gallery/server/FeedService.svc");
}
}
public void Installing(Feature feature)
{
var featureName = feature.Descriptor.Id;
_dataMigrationManager.Update(featureName);
}
public void Uninstalling(Feature feature)
{
}
public void Installed(Feature feature)
{
//_reportsCoordinator.Register("Scheduler", "Schedule Triggered", "via Rules API");
//_reportsCoordinator.Register("IScheduledTask.Execute", "Schedule Triggered", "via IScheduledTask interface");
}
