Sage.Project.InitializeConfiguration C# (CSharp) Method

        internal static SageContext InitializeConfiguration(SageContext context)
        {
            string projectConfigPathBinDir = Path.Combine(Project.AssemblyCodeBaseDirectory, ProjectConfiguration.ProjectConfigName);
            string projectConfigPathProjDir = Path.Combine(Project.AssemblyCodeBaseDirectory, "..\\" + ProjectConfiguration.ProjectConfigName);

            string projectConfigPath = projectConfigPathBinDir;
            if (File.Exists(projectConfigPathProjDir))
            {
                projectConfigPath = projectConfigPathProjDir;
            }

            var projectConfig = ProjectConfiguration.Create();

            if (!File.Exists(projectConfigPath))
            {
                log.Warn("Project configuration file not found; configuration initialized with default values");
                return new SageContext(context);
            }

            installOrder = new List<string>();
            extensions = new OrderedDictionary<string, ExtensionInfo>();

            if (File.Exists(projectConfigPath))
                projectConfig.Parse(projectConfigPath);

            if (projectConfig.Locales.Count == 0)
            {
                var defaultLocale = new LocaleInfo();
                projectConfig.Locales.Add(defaultLocale.Name, defaultLocale);
            }

            var result = projectConfig.ValidationResult;
            if (!result.Success)
            {
                initializationError = result.Exception;
                initializationProblemInfo = new ProblemInfo(ProblemType.ProjectSchemaValidationError, result.SourceFile);
            }
            else
            {
                configuration = projectConfig;

                // this will ensure the new context uses the just
                // created configuration immediately
                context = new SageContext(context);

                var extensionManager = new ExtensionManager();
                try
                {
                    extensionManager.Initialize(context);
                }
                catch (ProjectInitializationException ex)
                {
                    initializationError = ex;
                    initializationProblemInfo = new ProblemInfo(ex.Reason, ex.SourceFile);
                    if (ex.Reason == ProblemType.MissingExtensionDependency)
                    {
                        initializationProblemInfo.InfoBlocks
                            .Add("Dependencies", ex.Dependencies.ToDictionary(name => name));
                    }
                }

                if (initializationError == null)
                {
                    var missingDependencies = projectConfig.Dependencies
                        .Where(name => extensionManager.Count(ex => ex.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)) == 0)
                        .ToList();

                    var extraDependencies = extensionManager
                        .Where(extension => projectConfig.Dependencies.Count(name => name.Equals(extension.Name, StringComparison.InvariantCultureIgnoreCase)) == 0)
                        .ToList();

                    if (missingDependencies.Count != 0)
                    {
                        string errorMessage =
                            string.Format("Project is missing one or more dependencies ({0}) - installation cancelled.",
                            string.Join(", ", missingDependencies));

                        initializationError = new ProjectInitializationException(errorMessage);
                        initializationProblemInfo = new ProblemInfo(ProblemType.MissingDependency);
                        initializationProblemInfo.InfoBlocks
                            .Add("Dependencies", missingDependencies.ToDictionary(name => name));
                    }

                    if (extraDependencies.Count != 0)
                    {
                        log.WarnFormat("There are additional, unreferenced extensions in the extensions directory: {0}", string.Join(",", extraDependencies));
                    }

                    foreach (var name in projectConfig.Dependencies)
                    {
                        var extension = extensionManager.First(ex => ex.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
                        installOrder.Add(extension.Config.Id);
                        Project.RelevantAssemblies.AddRange(extension.Assemblies);

                        projectConfig.RegisterExtension(extension.Config);
                        extensions.Add(extension.Config.Id, extension);
                    }

                    // fire this event at the end rather than once for each extension
                    var totalAssemblies = extensionManager.Sum(info => info.Assemblies.Count);
                    if (totalAssemblies != 0)
                    {
                        if (Project.AssembliesUpdated != null)
                        {
                            log.DebugFormat("{0} extension assemblies loaded, triggering AssembliesUpdated event", totalAssemblies);
                            Project.AssembliesUpdated(null, EventArgs.Empty);
                        }
                    }

                    installOrder.Add(projectConfig.Id);
                    projectConfig.RegisterRoutes();
                    context.LmCache.Put(ConfigWatchName, DateTime.Now, projectConfig.Files);
                }
            }

            return context;
        }