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"); }