public override void Building(FeatureBuildingContext context)
        {
            var baseTheme = context.ExtensionInfo.Manifest.ConfigurationRoot["basetheme"];

            if (baseTheme != null && baseTheme.Length != 0)
            {
                if (!context.FeatureDependencyIds.Contains(baseTheme))
                {
                    var temp = context.FeatureDependencyIds.ToList();
                    temp.Add(baseTheme);
                    context.FeatureDependencyIds = temp.ToArray();
                }
            }
        }
Exemple #2
0
        public override void Building(FeatureBuildingContext context)
        {
            if (context.ExtensionInfo.Manifest.ModuleInfo is ThemeAttribute)
            {
                var extensionInfo = new ThemeExtensionInfo(context.ExtensionInfo);

                if (extensionInfo.HasBaseTheme())
                {
                    context.FeatureDependencyIds = context
                                                   .FeatureDependencyIds
                                                   .Concat(new [] { extensionInfo.BaseTheme })
                                                   .ToArray();
                }

                context.ExtensionInfo = extensionInfo;
            }
        }
Exemple #3
0
        public override void Building(FeatureBuildingContext context)
        {
            var moduleInfo = context.ExtensionInfo.Manifest.ModuleInfo;

            if (moduleInfo is ThemeAttribute || (moduleInfo is ModuleMarkerAttribute &&
                                                 moduleInfo.Type.Equals("Theme", StringComparison.OrdinalIgnoreCase)))
            {
                var extensionInfo = new ThemeExtensionInfo(context.ExtensionInfo);

                if (extensionInfo.HasBaseTheme())
                {
                    context.FeatureDependencyIds = context
                                                   .FeatureDependencyIds
                                                   .Concat(new[] { extensionInfo.BaseTheme })
                                                   .ToArray();
                }

                context.ExtensionInfo = extensionInfo;
            }
        }
 public virtual void Building(FeatureBuildingContext context)
 {
 }
Exemple #5
0
        public IEnumerable <IFeatureInfo> GetFeatures(
            IExtensionInfo extensionInfo,
            IManifestInfo manifestInfo)
        {
            var featuresInfos = new List <IFeatureInfo>();

            // Features and Dependencies live within this section
            var features = manifestInfo.ModuleInfo.Features.ToList();

            if (features.Count > 0)
            {
                foreach (var feature in features)
                {
                    if (String.IsNullOrWhiteSpace(feature.Id))
                    {
                        throw new ArgumentException(
                                  $"A feature is missing a mandatory 'Id' property in the Module '{extensionInfo.Id}'");
                    }

                    var featureId   = feature.Id;
                    var featureName = feature.Name ?? feature.Id;

                    var featureDependencyIds = feature.Dependencies
                                               .Select(e => e.Trim()).ToArray();

                    if (!int.TryParse(feature.Priority ?? manifestInfo.ModuleInfo.Priority, out int featurePriority))
                    {
                        featurePriority = 0;
                    }

                    var featureCategory          = feature.Category ?? manifestInfo.ModuleInfo.Category;
                    var featureDescription       = feature.Description ?? manifestInfo.ModuleInfo.Description;
                    var featureDefaultTenantOnly = feature.DefaultTenantOnly;

                    var context = new FeatureBuildingContext
                    {
                        FeatureId            = featureId,
                        FeatureName          = featureName,
                        Category             = featureCategory,
                        Description          = featureDescription,
                        ExtensionInfo        = extensionInfo,
                        ManifestInfo         = manifestInfo,
                        Priority             = featurePriority,
                        FeatureDependencyIds = featureDependencyIds,
                        DefaultTenantOnly    = featureDefaultTenantOnly,
                    };

                    foreach (var builder in _featureBuilderEvents)
                    {
                        builder.Building(context);
                    }

                    var featureInfo = new FeatureInfo(
                        featureId,
                        featureName,
                        featurePriority,
                        featureCategory,
                        featureDescription,
                        extensionInfo,
                        featureDependencyIds,
                        featureDefaultTenantOnly);

                    foreach (var builder in _featureBuilderEvents)
                    {
                        builder.Built(featureInfo);
                    }

                    featuresInfos.Add(featureInfo);
                }
            }
            else
            {
                // The Extension has only one feature, itself, and that can have dependencies
                var featureId   = extensionInfo.Id;
                var featureName = manifestInfo.Name;

                var featureDependencyIds = manifestInfo.ModuleInfo.Dependencies
                                           .Select(e => e.Trim()).ToArray();

                if (!int.TryParse(manifestInfo.ModuleInfo.Priority, out int featurePriority))
                {
                    featurePriority = 0;
                }

                var featureCategory          = manifestInfo.ModuleInfo.Category;
                var featureDescription       = manifestInfo.ModuleInfo.Description;
                var featureDefaultTenantOnly = manifestInfo.ModuleInfo.DefaultTenantOnly;

                var context = new FeatureBuildingContext
                {
                    FeatureId            = featureId,
                    FeatureName          = featureName,
                    Category             = featureCategory,
                    Description          = featureDescription,
                    ExtensionInfo        = extensionInfo,
                    ManifestInfo         = manifestInfo,
                    Priority             = featurePriority,
                    FeatureDependencyIds = featureDependencyIds,
                    DefaultTenantOnly    = featureDefaultTenantOnly,
                };

                foreach (var builder in _featureBuilderEvents)
                {
                    builder.Building(context);
                }

                var featureInfo = new FeatureInfo(
                    context.FeatureId,
                    context.FeatureName,
                    context.Priority,
                    context.Category,
                    context.Description,
                    context.ExtensionInfo,
                    context.FeatureDependencyIds,
                    context.DefaultTenantOnly);

                foreach (var builder in _featureBuilderEvents)
                {
                    builder.Built(featureInfo);
                }

                featuresInfos.Add(featureInfo);
            }

            return(featuresInfos);
        }