Exemple #1
0
 protected void Application_Start()
 {
     DashboardConfig.RegisterService(RouteTable.Routes);
     RouteConfig.RegisterRoutes(RouteTable.Routes);
     ASPxWebControl.CallbackError += Application_Error;
     ControllerBuilder.Current.SetControllerFactory(typeof(CustomControllerFactory));
 }
Exemple #2
0
        public PirSensorService(DashboardConfig cfg, MonitorService monitorService)
        {
            this._monitorService      = monitorService;
            this.PirSensorPin         = cfg.PirSensorPin;
            this.MonitorFadeoutTimeMs = (int)(cfg.MonitorFadeoutTimeMinutes * 60 * 1000);

            if (TimeSpan.TryParse(cfg.WakeupTime, CultureInfo.InvariantCulture, out TimeSpan wakeupTime))
            {
                this.WakeupTime = wakeupTime;
                Logger.Info($"Wakeup at {this.WakeupTime}");
            }
            else
            {
                this.WakeupTime = new TimeSpan(06, 00, 00);
                Logger.Warn($"Wakeup Fallback at {this.WakeupTime}");
            }
            if (TimeSpan.TryParse(cfg.BedTime, CultureInfo.InvariantCulture, out TimeSpan bedTime))
            {
                this.BedTime = bedTime;
                Logger.Info($"Bedtime at {this.BedTime}");
            }
            else
            {
                this.BedTime = new TimeSpan(22, 00, 00);
                Logger.Warn($"Bedtime Fallback at {this.BedTime}");
            }
        }
Exemple #3
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // Bind the Appsettings.json to shiftDashboardConfig
            DashboardConfig shiftDashboardConfig = new DashboardConfig();

            Configuration.GetSection(shiftDashboardConfig.Position).Bind(shiftDashboardConfig);
            services.AddSingleton <DashboardConfig>(shiftDashboardConfig);


            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder.AllowAnyOrigin()
                                  .AllowAnyMethod()
                                  .AllowAnyHeader());
            });

            services.Configure <ForwardedHeadersOptions>(options =>
            {
                options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
            });


            // Initialize DB Context
            services.AddDbContext <DashboardContext>(options =>
            {
                var builder = new NpgsqlDbContextOptionsBuilder(options);
                builder.SetPostgresVersion(new Version(9, 6));
                options.UseNpgsql(shiftDashboardConfig.ConnectionString);
            }
                                                     );

            // Shift Api Service (Need a DB Context
            services.AddTransient <IApiService, ApiService>();

            // Schedule Tasks.
            services.AddQuartz(q =>
            {
                // Create a "key" for the job
                var updateDelegateJobKey = new JobKey("UpdateDelegateJob");

                // Register the job with the DI container
                q.AddJob <UpdateDelegateJob>(opts => opts.WithIdentity(updateDelegateJobKey));

                // Create a trigger for the job
                //
                q.AddTrigger(opts => opts
                             .ForJob(updateDelegateJobKey)
                             .WithIdentity("UpdateDelegateJob-trigger") // give the trigger a unique name
                             .WithCronSchedule("0 */45 * * * ?"));;     // run every 45 minutes

                // Use a Scoped container to create jobs. I'll touch on this later
                q.UseMicrosoftDependencyInjectionScopedJobFactory();
            });

            // Add the Quartz.NET hosted service
            services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);
            services.AddControllersWithViews();
            services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
        }
Exemple #4
0
        /// <summary>
        /// Perform an automatic placement of the block. Also updates the configuration of
        /// the block to match where it was placed.
        /// </summary>
        /// <param name="config">The user configuration information to update.</param>
        /// <param name="block">The block wrapper tha tmus tbe placed.</param>
        /// <param name="columns">The dashboard columns in the UI.</param>
        private void AutoConfigBlockPlacement(DashboardConfig config, DashboardBlockWrapper block, List <DashboardColumn> columns, bool isRequired)
        {
            var shortestColumn = columns.OrderBy(c => c.Placeholder.Controls.Count).First();

            if (isRequired)
            {
                block.Config.Column = columns.IndexOf(shortestColumn);
                block.Config.Order  = 0;
                int i = 1;
                config.Blocks.Where(b => b.Column == block.Config.Column && b.BlockId != block.Config.BlockId)
                .ToList()
                .ForEach(b => b.Order = i++);

                columns[block.Config.Column].Placeholder.Controls.AddAt(0, block);
            }
            else
            {
                block.Config.Column = columns.IndexOf(shortestColumn);
                block.Config.Order  = 999;
                int i = 0;
                config.Blocks.Where(b => b.Column == block.Config.Column)
                .ToList()
                .ForEach(b => b.Order = i++);

                columns[block.Config.Column].Placeholder.Controls.Add(block);
            }
        }
 public HomeController(ILogger <HomeController> logger, DashboardConfig dashboardconfig, DashboardContext dbcontext, IApiService apiService)
 {
     _dashboardOptions = dashboardconfig;
     _logger           = logger;
     _dbcontext        = dbcontext;
     _apiService       = apiService;
 }
Exemple #6
0
 protected void Application_Start()
 {
     AreaRegistration.RegisterAllAreas();
     FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
     RouteConfig.RegisterRoutes(RouteTable.Routes);
     BundleConfig.RegisterBundles(BundleTable.Bundles);
     DashboardConfig.Config();
 }
Exemple #7
0
        private WeatherForecast _cachedResult; // if OWM is down

        public WeatherService(ILogger <WeatherService> logger, DashboardConfig cfg)
        {
            this._logger    = logger;
            this._appId     = cfg?.OpenWeatherMapAppId ?? throw new InvalidDataException("DashboardConfig.OpenWeatherMapAppId is not set");
            this._units     = cfg?.OpenWeatherMapUnits ?? throw new InvalidDataException("DashboardConfig.OpenWeatherMapUnits is not set");
            this._latitude  = cfg?.WeatherLocationLatitude ?? throw new InvalidDataException("DashboardConfig.WeatherLocationLatitude is not set");
            this._longitude = cfg?.WeatherLocationLongitude ?? throw new InvalidDataException("DashboardConfig.WeatherLocationLongitude is not set");
            this._language  = cfg?.OpenWeatherMapLang ?? throw new InvalidDataException("DashboardConfig.OpenWeatherMapLang is not set");
        }
 public async Task UpdateDashboard(UserId user, DashboardConfig dashboard)
 {
     var dashboardModel = new DashboardConfigModel(
         dashboard.Id,
         dashboard.Name,
         dashboard.Tags
         .Select(t => new DashboardConfigTagModel(t.Tag, t.Target))
         .ToList());
     await _repository.AddOrUpdateDashboard(user, dashboardModel);
 }
        protected void Application_Start()
        {
            DashboardConfig.RegisterService(RouteTable.Routes);
            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            ModelBinders.Binders.DefaultBinder = new DevExpress.Web.Mvc.DevExpressEditorsBinder();

            DevExpress.Web.ASPxWebControl.CallbackError += Application_Error;
        }
 public void OpenFileName(string str)
 {
     if (str != null)
     {
         DashboardConfigBundle configBundle = JsonConvert.DeserializeObject <DashboardConfigBundle>(File.ReadAllText(str));
         //dc.AddItemsToConsole(JsonConvert.SerializeObject(configBundle, Formatting.Indented));
         DashboardConfig_ = configBundle.DashboardConfig_;
         List <IDashboardCellConfig> dashboardCellConfigs = configBundle.DashboardCellConfigs_;
         ClearDashboardCells();
         AddDashBoardCells(dashboardCellConfigs);
         dc.AddItemsToConsole($"Dashboard \"{DashboardConfig_.DashboardName_}\" loaded");
     }
 }
Exemple #11
0
        /// <summary>
        /// Saves the user configuartion about how they want their dashboard to look.
        /// </summary>
        /// <param name="config">The dashboard configuartion for the user.</param>
        private void SaveConfig(DashboardConfig config)
        {
            //
            // Explicitly set the order of the blocks.
            //
            foreach (var blockGroup in config.Blocks.GroupBy(b => b.Column))
            {
                int order = 0;

                blockGroup.OrderBy(b => b.Order).ToList().ForEach(b => b.Order = order++);
            }

            SetBlockUserPreference("config", JsonConvert.SerializeObject(config));
        }
 public BackgroundImageService(ILogger <BackgroundImageService> logger, DashboardConfig cfg, IWebHostEnvironment env, ReverseGeoCodingService geoCodingService)
 {
     this._logger           = logger;
     this._geoCodingService = geoCodingService ?? throw new ArgumentNullException();
     this._imagesSourcePath = cfg?.BackgroundImagesPath ?? throw new InvalidDataException("DashboardConfig.BackgroundImagesPath is not set");
     if (!System.IO.Directory.Exists(this._imagesSourcePath))
     {
         throw new DirectoryNotFoundException(this._imagesSourcePath);
     }
     this._localCopyFullPath = Path.Combine(env.WebRootPath, BasePath, "background.jpg");
     this._relativePath      = Path.Combine(BasePath, "background.jpg");
     this._nextBackgrounds   = new Queue <BackgroundImage>(31); // up to one month ahead
     this._logger.LogInformation(nameof(BackgroundImageService) + " created");
 }
        public GoogleCalendarService(DashboardConfig cfg, CalendarService googleService)
        {
            Dictionary <string, string> calendars = cfg?.Calendars;

            if (calendars == null)
            {
                throw new InvalidDataException("DashboardConfig.Calendars is null");
            }
            if (calendars.Count == 0)
            {
                throw new InvalidDataException("DashboardConfig.Calendars is empty");
            }
            this._calendarIds   = calendars.Keys.ToArray();
            this._googleService = googleService ?? throw new ArgumentNullException(nameof(googleService));
        }
        public MainWindow()
        {
            InitializeComponent();
            DataContext = this;
            // load a dashboard in the view space
            DashboardConfig dashboardConfig = new DashboardConfig("Dashboard");

            DashboardUC_          = new DashboardUC(dashboardConfig);
            MainContainer.Content = DashboardUC_;
            //this.Title = DashboardUC_.DashboardConfig_.DashboardName_;
            DashboardUC_.PropertyChanged += DashboardUC__PropertyChanged;
            //AddSeedCells();
            String fileNameStr = (String)((App)Application.Current).Properties["FilePathArgName"];

            DashboardUC_.OpenFileName(fileNameStr);
        }
        public static IServiceCollection AddConfiguration(this IServiceCollection services, out DashboardConfig config)
        {
            var builder = new ConfigurationBuilder()
                          .AddJsonFile("./secrets.json")
                          .AddEnvironmentVariables("DB_");

            IConfigurationRoot root = builder.Build();

            var dbconfig = new DashboardConfig();

            ConfigurationBinder.Bind(root, dbconfig);

            services.AddSingleton <DashboardConfig>(dbconfig);
            config = dbconfig;
            return(services);
        }
Exemple #16
0
        /// <summary>
        /// Get the config for the current user on how they want their dashboard
        /// to look.
        /// </summary>
        /// <returns>The configuration object for the dashboard.</returns>
        private DashboardConfig GetConfig()
        {
            var             configString = GetBlockUserPreference("config");
            DashboardConfig config       = null;

            try
            {
                config = JsonConvert.DeserializeObject <DashboardConfig>(configString);
                if (config == null)
                {
                    config = new DashboardConfig {
                        Layout = GetAttributeValue("DefaultLayout")
                    };
                }
            }
            catch
            {
                config = new DashboardConfig {
                    Layout = GetAttributeValue("DefaultLayout")
                };
            }

            return(config);
        }
Exemple #17
0
 public ApiService(ILogger <ApiService> logger, DashboardConfig dashboardconfig, DashboardContext dbcontext)
 {
     _dashboardOptions = dashboardconfig;
     _logger           = logger;
     _dbcontext        = dbcontext;
 }
 public DashboardUC(DashboardConfig dashboardConfig)
 {
     DashboardConfig_ = dashboardConfig;
     DoInitialWireUp();
 }
Exemple #19
0
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();
            services.AddServerSideBlazor();

            // Bind the Appsettings.json to shiftDashboardConfig
            DashboardConfig shiftDashboardConfig = new DashboardConfig();

            Configuration.GetSection(shiftDashboardConfig.Position).Bind(shiftDashboardConfig);
            services.AddSingleton <DashboardConfig>(shiftDashboardConfig);

            // Initialize DB Context
            services.AddDbContext <DashboardContext>(options =>
            {
                var builder = new NpgsqlDbContextOptionsBuilder(options);
                builder.SetPostgresVersion(new Version(9, 6));
                options.UseNpgsql(shiftDashboardConfig.ConnectionString);
            }
                                                     );

            // Shift Api Service (Need a DB Context
            services.AddTransient <IApiService, ApiService>();

            // Schedule Tasks.
            services.AddQuartz(q =>
            {
                // Create a "key" for the job
                var updateDelegateJobKey = new JobKey("UpdateDelegateJob");

                // Register the job with the DI container
                q.AddJob <UpdateDelegateJob>(opts => opts.WithIdentity(updateDelegateJobKey));

                // Create a trigger for the job
                //
                q.AddTrigger(opts => opts
                             .ForJob(updateDelegateJobKey)
                             .WithIdentity("UpdateDelegateJob-trigger") // give the trigger a unique name
                             .WithCronSchedule("0 */45 * * * ?"));;     // run every 45 minutes

                // Use a Scoped container to create jobs. I'll touch on this later
                q.UseMicrosoftDependencyInjectionScopedJobFactory();
            });

            // Add the Quartz.NET hosted service

            services.AddQuartzHostedService(
                q => q.WaitForJobsToComplete = true);

            if (services.All(x => x.ServiceType != typeof(HttpClient)))
            {
                services.AddScoped(
                    s =>
                {
                    var navigationManager = s.GetRequiredService <NavigationManager>();
                    return(new HttpClient
                    {
                        BaseAddress = new Uri(navigationManager.BaseUri)
                    });
                });
            }

            services.AddBlazorise(options => { options.ChangeTextOnKeyPress = true; });
            services.AddBootstrapProviders();
            services.AddFontAwesomeIcons();
        }
 public async Task Handle(UserId user, DashboardConfig dashboard) =>
 await _manager.UpdateDashboard(user, dashboard);
Exemple #21
0
        /// <summary>
        /// Build and layout all the blocks onto the web page.
        /// </summary>
        /// <param name="config">User configuration data that specifies how things should be laid out.</param>
        private void BuildBlocks(DashboardConfig config)
        {
            var sourcePageGuid = GetAttributeValue("SourcePage").AsGuidOrNull();

            if (sourcePageGuid.HasValue)
            {
                var sourcePage = PageCache.Read(sourcePageGuid.Value);

                if (sourcePage != null)
                {
                    var   blocks = GetAvailableBlocks();
                    Panel pnlRow = new Panel {
                        CssClass = "row"
                    };
                    List <DashboardBlockWrapper> dashboardBlocks = new List <DashboardBlockWrapper>();
                    bool needSave = false;

                    phControls.Controls.Add(pnlRow);
                    var columns = BuildColumns(config, pnlRow);

                    foreach (var block in blocks)
                    {
                        DashboardBlockConfig blockConfig = null;

                        blockConfig = config.Blocks.Where(b => b.BlockId == block.BlockId).FirstOrDefault();
                        if (blockConfig == null)
                        {
                            blockConfig         = new DashboardBlockConfig(block.BlockId);
                            blockConfig.Visible = block.DefaultVisible;
                            config.Blocks.Add(blockConfig);
                            needSave = true;
                        }

                        if (block.Required)
                        {
                            blockConfig.Visible = true;
                        }

                        if (blockConfig.Visible)
                        {
                            var control = TemplateControl.LoadControl(block.BlockCache.BlockType.Path);
                            control.ClientIDMode = ClientIDMode.AutoID;

                            var  blockControl    = control as RockBlock;
                            bool canEdit         = block.BlockCache.IsAuthorized(Authorization.EDIT, CurrentPerson);
                            bool canAdministrate = block.BlockCache.IsAuthorized(Authorization.ADMINISTRATE, CurrentPerson);

                            blockControl.SetBlock(PageCache, block.BlockCache, canEdit, canAdministrate);
                            block.BlockCache.BlockType.SetSecurityActions(blockControl);

                            var blockWrapper = new DashboardBlockWrapper(blockControl, block.BlockCache, blockConfig);
                            blockWrapper.ShowDelete = !block.Required;

                            dashboardBlocks.Add(blockWrapper);
                        }
                    }

                    //
                    // Add all the blocks that are properly layed out already.
                    //
                    var existingBlocks = dashboardBlocks.Where(b => b.Config.Column < columns.Count);
                    foreach (var blockGroup in existingBlocks.GroupBy(b => b.Config.Column))
                    {
                        var sortedBlocks = blockGroup.OrderBy(b => b.Config.Order);

                        foreach (var block in sortedBlocks)
                        {
                            columns[block.Config.Column].Placeholder.Controls.Add(block);
                        }
                    }

                    //
                    // Add in blocks that are new or don't currently fit.
                    //
                    var newBlocks = dashboardBlocks.Where(b => b.Config.Column >= columns.Count);
                    foreach (var blockGroup in newBlocks.GroupBy(b => b.Config.Column))
                    {
                        var sortedBlocks = blockGroup.OrderBy(b => b.Config.Order);

                        foreach (var block in sortedBlocks)
                        {
                            bool isRequired = blocks.Where(b => b.BlockId == block.Config.BlockId).First().Required;
                            AutoConfigBlockPlacement(config, block, columns, isRequired);
                            needSave = true;
                        }
                    }

                    //
                    // Cleanup the config for any blocks that don't exist anymore.
                    //
                    var missingKeys = config.Blocks
                                      .Where(b => !blocks.Where(db => b.BlockId == db.BlockId).Any())
                                      .Select(b => b.BlockId)
                                      .ToList();
                    foreach (var missingKey in missingKeys)
                    {
                        config.Blocks.RemoveAll(b => b.BlockId == missingKey);
                        needSave = true;
                    }

                    if (needSave)
                    {
                        SaveConfig(config);
                    }
                }
            }
        }
Exemple #22
0
        /// <summary>
        /// Build the columns that will be available for use based on the user's preferences.
        /// </summary>
        /// <param name="config">The user configuration data to use.</param>
        /// <param name="pnlRow">The panel control that will contain the columns.</param>
        private List <DashboardColumn> BuildColumns(DashboardConfig config, Panel pnlRow)
        {
            List <DashboardColumn> columns = new List <DashboardColumn>();
            DashboardColumn        column;

            if (config.Layout == TWO_COLUMN)
            {
                for (int i = 0; i < 2; i++)
                {
                    column = new DashboardColumn("col-md-6", i);
                    pnlRow.Controls.Add(column.Panel);
                    columns.Add(column);
                }
            }
            else if (config.Layout == FOUR_COLUMN)
            {
                for (int i = 0; i < 4; i++)
                {
                    column = new DashboardColumn("col-md-3", i);
                    pnlRow.Controls.Add(column.Panel);
                    columns.Add(column);
                }
            }
            else if (config.Layout == ONE_TWO_COLUMN)
            {
                column = new DashboardColumn("col-md-6", 0);
                pnlRow.Controls.Add(column.Panel);
                columns.Add(column);

                for (int i = 1; i < 3; i++)
                {
                    column = new DashboardColumn("col-md-3", i);
                    pnlRow.Controls.Add(column.Panel);
                    columns.Add(column);
                }
            }
            else if (config.Layout == TWO_ONE_COLUMN)
            {
                for (int i = 0; i < 2; i++)
                {
                    column = new DashboardColumn("col-md-3", i);
                    pnlRow.Controls.Add(column.Panel);
                    columns.Add(column);
                }

                column = new DashboardColumn("col-md-6", 2);
                pnlRow.Controls.Add(column.Panel);
                columns.Add(column);
            }
            else /* THREE_COLUMN */
            {
                for (int i = 0; i < 3; i++)
                {
                    column = new DashboardColumn("col-md-4", i);
                    pnlRow.Controls.Add(column.Panel);
                    columns.Add(column);
                }
            }

            return(columns);
        }