View model for creating the main geosite view (Views/Home/Index.cshtml).
Ejemplo n.º 1
0
        /// <summary>
        /// Create a Geosite object by loading the "region.json" file and enumerating plug-ins, using the specified paths.
        /// </summary>
        public static Geosite LoadSiteData(string regionJsonFilePath, string basePath, string appDataFolderPath)
        {
            var jsonDataRegion    = new JsonDataRegion(appDataFolderPath).LoadFile(regionJsonFilePath);
            var pluginDirectories = PluginLoader.GetPluginDirectories(jsonDataRegion, basePath);

            PluginLoader.VerifyDirectoriesExist(pluginDirectories);
            var pluginFolderPaths = pluginDirectories.SelectMany(path => Directory.EnumerateDirectories(path));
            var pluginConfigData  = GetPluginConfigurationData(pluginFolderPaths, appDataFolderPath);
            var pluginFolderNames = pluginFolderPaths.Select(path => PluginLoader.GetPluginFolderPath(basePath, path)).ToList();
            var pluginModuleNames = pluginFolderPaths.Select(path => PluginLoader.GetPluginModuleName(basePath, path)).ToList();
            var geosite           = new Geosite(jsonDataRegion, pluginFolderNames, pluginModuleNames, pluginConfigData);

            return(geosite);
        }
Ejemplo n.º 2
0
        // Example plugin.json file:
        // {
        //     css: [
        //         "plugins/layer_selector/main.css",
        //         "//cdn.sencha.io/ext-4.1.1-gpl/resources/css/ext-all.css"
        //     ],
        //     use: {
        //         underscore: { attach: "_" },
        //         extjs: { attach: "Ext" }
        //     }
        // }

        private static void MergePluginConfigurationData(Geosite geosite, List <JsonData> pluginConfigData)
        {
            var cssUrls       = new List <string>();
            var useClauses    = new List <string>();
            var useClauseDict = new Dictionary <string, string>();

            foreach (var jsonData in pluginConfigData)
            {
                // Parse and validate the plugin's JSON configuration data
                var jsonObj = jsonData.Validate();

                JToken token;
                if (jsonObj.TryGetValue("css", out token))
                {
                    // This config has CSS urls - add them to the list
                    cssUrls.AddRange(token.Values <string>());
                }
                if (jsonObj.TryGetValue("use", out token))
                {
                    // This config has "use" clauses - add unique ones to the list
                    foreach (JProperty p in token.Children())
                    {
                        var value = Regex.Replace(p.Value.ToString(), @"\s", ""); // remove whitespace
                        if (useClauseDict.ContainsKey(p.Name))
                        {
                            if (useClauseDict[p.Name] != value)
                            {
                                var message = string.Format(
                                    "Plugins define 'use' clause '{0}' differently: '{1}' vs. '{2}'",
                                    p.Name, value, useClauseDict[p.Name]);
                                throw new ApplicationException(message);
                            }
                        }
                        else
                        {
                            useClauseDict[p.Name] = value;
                            useClauses.Add(p.ToString());
                        }
                    }
                }
            }
            geosite.PluginCssUrls         = cssUrls;
            geosite.ConfigurationForUseJs = string.Join("," + Environment.NewLine, useClauses);
        }
Ejemplo n.º 3
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            // Configure log4net from the info in Web.config
            log4net.Config.XmlConfigurator.Configure();
            _log.Info("Initializing GeositeFramework, version " + _geositeFrameworkVersion);

            // Load geosite configuration data (which loads and validates all config files)
            GeositeData = LoadGeositeData();

            // Create a logger for each plugin
            foreach (string pluginName in GeositeData.PluginFolderNames)
            {
                CreateLogger(pluginName);
            }
        }
Ejemplo n.º 4
0
        public void TestValidRegionData()
        {
            var regionJson = @"
                {
                    'titleMain': { 'text': 'Geosite Framework Sample', 'url': 'http://www.azavea.com/' },
                    'titleDetail':  { 'text': 'Sample Region', 'url': 'http://www.azavea.com/' },
                    'initialExtent': [ -98.61328125, 17.392579271057766, -79.716796875,31.653381399664 ],
                    'headerLinks': [
                        { 'text': 'Azavea', 'url': 'http://www.azavea.com/' },
                        { 'text': 'GIS', 'url': 'http://en.wikipedia.org/wiki/Geographic_information_system' }
                    ],
                    'basemaps': [
                        {
                            'name': 'Topological',
                            'url': 'http://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer'
                        }
                    ],
                    'pluginOrder': [ 'layer_selector', 'measure' ]
                }";
            var pluginFolderNames = new List<string> { "nearshore_waves", "measure", "layer_selector", "explode"};
            var pluginJsonData = new List<JsonData> { LoadPluginData(@"{ css: ['main.css'], use: { underscore: { attach: '_' } } }") };
            var geosite = new Geosite(LoadRegionData(regionJson), pluginFolderNames, pluginJsonData);

            Expect(geosite.TitleMain.Text, EqualTo("Geosite Framework Sample"));
            Expect(geosite.TitleDetail.Text, EqualTo("Sample Region"));
            Expect(geosite.HeaderLinks.Count, EqualTo(2));
            Expect(geosite.HeaderLinks[0].Url, EqualTo("http://www.azavea.com/"));
            Expect(geosite.HeaderLinks[1].Text, EqualTo("GIS"));
            Expect(geosite.PluginModuleIdentifiers, EqualTo("'plugins/layer_selector/main', 'plugins/measure/main', 'plugins/nearshore_waves/main', 'plugins/explode/main'"));
            Expect(geosite.PluginVariableNames, EqualTo("p0, p1, p2, p3"));
            Expect(geosite.PluginCssUrls, Contains("main.css"));
            Expect(geosite.ConfigurationForUseJs, Contains("underscore"));

            // Test that "pluginFolderNames" was correctly added to the JSON
            var jsonObj = JObject.Parse(geosite.RegionDataJson);
            var orderedFolderNames = jsonObj["pluginFolderNames"].Select(t => (string)t).ToList();
            Expect(orderedFolderNames, EqualTo(new List<string> { "layer_selector", "measure", "nearshore_waves", "explode" }));
        }
Ejemplo n.º 5
0
        // Example plugin.json file:
        // {
        //     css: [
        //         "plugins/layer_selector/main.css",
        //         "//cdn.sencha.io/ext-4.1.1-gpl/resources/css/ext-all.css"
        //     ],
        //     use: {
        //         underscore: { attach: "_" },
        //         extjs: { attach: "Ext" }
        //     }
        // }
        private static void MergePluginConfigurationData(Geosite geosite, List<JsonData> pluginConfigData)
        {
            var cssUrls = new List<string>();
            var useClauses = new List<string>();
            var useClauseDict = new Dictionary<string, string>();
            foreach (var jsonData in pluginConfigData)
            {
                // Parse and validate the plugin's JSON configuration data
                var jsonObj = jsonData.Validate();

                JToken token;
                if (jsonObj.TryGetValue("css", out token))
                {
                    // This config has CSS urls - add them to the list
                    cssUrls.AddRange(token.Values<string>());
                }
                if (jsonObj.TryGetValue("use", out token))
                {
                    // This config has "use" clauses - add unique ones to the list
                    foreach (JProperty p in token.Children())
                    {
                        var value = Regex.Replace(p.Value.ToString(), @"\s", ""); // remove whitespace
                        if (useClauseDict.ContainsKey(p.Name))
                        {
                            if (useClauseDict[p.Name] != value)
                            {
                                var message = string.Format(
                                    "Plugins define 'use' clause '{0}' differently: '{1}' vs. '{2}'",
                                    p.Name, value, useClauseDict[p.Name]);
                                throw new ApplicationException(message);
                            }
                        }
                        else
                        {
                            useClauseDict[p.Name] = value;
                            useClauses.Add(p.ToString());
                        }
                    }
                }
            }
            geosite.PluginCssUrls = cssUrls;
            geosite.ConfigurationForUseJs = string.Join("," + Environment.NewLine, useClauses);
        }
Ejemplo n.º 6
0
 /// <summary>
 /// Create a Geosite object by loading the "region.json" file and enumerating plug-ins, using the specified paths.
 /// </summary>
 public static Geosite LoadSiteData(string regionJsonFilePath, string pluginsFolderPath, string appDataFolderPath)
 {
     var jsonDataRegion = new JsonDataRegion(appDataFolderPath).LoadFile(regionJsonFilePath);
     var pluginFolderPaths = Directory.EnumerateDirectories(pluginsFolderPath);
     var pluginConfigData = GetPluginConfigurationData(pluginFolderPaths, appDataFolderPath);
     var pluginFolderNames = pluginFolderPaths.Select(p => Path.GetFileName(p)).ToList();
     var geosite = new Geosite(jsonDataRegion, pluginFolderNames, pluginConfigData);
     return geosite;
 }
        private Translations PrepareLanguages(Geosite data)
        {
            var translations = new Translations();

            // Add all plugin translation files
            foreach (var plugin in data.PluginFolderNames)
            {
                var pluginLocalesPath = HostingEnvironment.MapPath(String.Format("~/{0}/locales", plugin));

                if (Directory.Exists(pluginLocalesPath))
                {
                    var pluginTranslations = Directory
                        .GetFiles(pluginLocalesPath, "*.json")
                        .ToDictionary(Path.GetFileNameWithoutExtension, toTranslationDictionary);

                    translations = mergeTranslations(pluginTranslations, translations);
                }
            }

            // Add core translation files
            var coreLocalesPath = HostingEnvironment.MapPath("~/locales");
            var coreTranslations = Directory
                .GetFiles(coreLocalesPath, "*.json")
                .ToDictionary(Path.GetFileNameWithoutExtension, toTranslationDictionary);

            translations = mergeTranslations(coreTranslations, translations);

            return translations;
        }
 /// <summary>
 /// Create a Geosite object by loading the "region.json" file and enumerating plug-ins, using the specified paths.
 /// </summary>
 public static Geosite LoadSiteData(string regionJsonFilePath, string basePath, string appDataFolderPath)
 {
     var jsonDataRegion = new JsonDataRegion(appDataFolderPath).LoadFile(regionJsonFilePath);
     var pluginDirectories = PluginLoader.GetPluginDirectories(jsonDataRegion, basePath);
     PluginLoader.VerifyDirectoriesExist(pluginDirectories);
     var pluginFolderPaths = pluginDirectories.SelectMany(path => Directory.EnumerateDirectories(path));
     var pluginConfigData = GetPluginConfigurationData(pluginFolderPaths, appDataFolderPath);
     var pluginFolderNames = pluginFolderPaths.Select(path => PluginLoader.GetPluginFolderPath(basePath, path)).ToList();
     var pluginModuleNames = pluginFolderPaths.Select(path => PluginLoader.GetPluginModuleName(basePath, path)).ToList();
     var geosite = new Geosite(jsonDataRegion, pluginFolderNames, pluginModuleNames, pluginConfigData);
     return geosite;
 }