Example #1
0
        public void Configuration(IAppBuilder app)
        {
            var _eventNotification = new NotificationService();
            // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
            GlobalConfiguration.Configuration.UseSqlServerStorage("PaytimeAzureDbContext");

            RecurringJob.AddOrUpdate(() => _eventNotification.GenerateNotification(), Cron.Daily(_cronHour, _cronMinutes));
            //RecurringJob.AddOrUpdate(() => _eventNotification.GenerateNotification(), Cron.Daily(09, 45));

            app.UseHangfireDashboard();
            app.UseHangfireServer();

            // Authentication
            app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

            app.UseCookieAuthentication(new CookieAuthenticationOptions());

            app.UseOpenIdConnectAuthentication(
                new OpenIdConnectAuthenticationOptions
                {
                    ClientId = clientId,
                    Authority = authority,
                    PostLogoutRedirectUri = postLogoutRedirectUri,
                    TokenValidationParameters = new System.IdentityModel.Tokens.TokenValidationParameters()
                    {
                        ValidateIssuer = false,
                        RoleClaimType = "roles"
                    }
                });
        }
        public void ConfigureOwin(IAppBuilder app, IUnityContainer container)
        {
            JobStorage.Current = CreateJobStorage(Stage.ConfigureOwin);

            // Configure Hangfire dashboard

            var securityService = container.Resolve<ISecurityService>();
            var moduleInitializerOptions = container.Resolve<IModuleInitializerOptions>();

            var appPath = "/" + moduleInitializerOptions.RoutePrefix;

            var authorizationFilters = new[]
            {
                    new PermissionBasedAuthorizationFilter(securityService)
                    {
                        Permission = PredefinedPermissions.BackgroundJobsManage
                    }
                };

            var dashboardOptions = new DashboardOptions
            {
                AppPath = appPath,
                AuthorizationFilters = authorizationFilters
            };

            app.UseHangfireDashboard(appPath + "hangfire", dashboardOptions);

            // Configure Hangfire server
            if (_options.StartServer)
            {
                app.UseHangfireServer(new BackgroundJobServerOptions { Activator = new UnityJobActivator(container) });
            }
        }
        public void Configuration(IAppBuilder app)
        {

            var authorizationFilter = new BasicAuthAuthorizationFilter(
                                new BasicAuthAuthorizationFilterOptions
                                {
                                    // Require secure connection for dashboard
                                    RequireSsl = true,
                                    // Case sensitive login checking
                                    LoginCaseSensitive = true,
                                    // Users
                                    Users = new[]
                                    {
                                        new BasicAuthAuthorizationUser
                                        {
                                            Login = "******",
                                            PasswordClear = "passW0rd!"
                                        }
                                    }
                                });

            var options = new DashboardOptions
            {
                AuthorizationFilters = new IAuthorizationFilter[]
                {
                    authorizationFilter
                }
            };
            GlobalConfiguration.Configuration.UseSqlServerStorage("DefaultConnection");

            app.UseHangfireDashboard("/hangfire", options);
            app.UseHangfireServer();

            ConfigureAuth(app);
        }
        public static void Configuration(IAppBuilder app)
        {
            // Enable the application to use a cookie to store information for the signed in user.
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/")
            });

            // Enable the application to use a cookie to store information about a user logging
            // in with a third party login provider. 
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enable the Reddit authentication provider.
            app.UseRedditAuthentication(GetRedditOptions());

            GlobalConfiguration.Configuration.UseSqlServerStorage("Hangfire");
            app.UseHangfireDashboard("/Hangfire", new DashboardOptions
            {
                AuthorizationFilters = new[] {new HangfireDashboardAuthorizationFilter(),}
            });
            app.UseHangfireServer();

            RecurringJob.AddOrUpdate<BulkFlairUpdateJob>(FlairJobId, job => job.Execute(), Cron.Minutely);
            RecurringJob.AddOrUpdate<BulkLeagueUpdateJob>(LeagueJobId, job => job.Execute(), Cron.Minutely);
        }
Example #5
0
        private void InitHangfire(IAppBuilder app)
        {
            var hangfireConfig = IoC.Container.Resolve<IHangfireConfig>();
            GlobalConfiguration.Configuration.UseSqlServerStorage(
                hangfireConfig.SqlServerConnectionString,
                new SqlServerStorageOptions()
                {
                    PrepareSchemaIfNecessary = true,
                    QueuePollInterval = TimeSpan.FromSeconds(1)
                });
            GlobalJobFilters.Filters.Add(new AutomaticRetryAttribute { Attempts = 3 });

            app.UseHangfireDashboard("/hangfire", new DashboardOptions
            {
                AuthorizationFilters = new[] { new MyRestrictiveAuthorizationFilter() }
            });

            LogProvider.SetCurrentLogProvider(new ElmahLogProvider(LogLevel.Trace));

            var options = new BackgroundJobServerOptions
            {
                WorkerCount = Environment.ProcessorCount * 5
            };
            app.UseHangfireServer(options);

        }
Example #6
0
      public void ConfigureHangFire(IAppBuilder app)
      {
         var storageOptions = new SqlServerStorageOptions
         {
            InvisibilityTimeout = TimeSpan.FromHours(2),
            QueuePollInterval = TimeSpan.FromMinutes(15.0)
         };
         GlobalConfiguration.Configuration
            .UseSqlServerStorage("TrainingManagerDb", storageOptions);

         // case msmq installed
         /*GlobalConfiguration.Configuration
            .UseSqlServerStorage("TrainingManagerDb")
            .UseMsmqQueues(@".\hangfire-{0}");*/



         var dashboardOptions = new DashboardOptions
         {
            AuthorizationFilters = new[] { new AuthorizationFilter { Roles = AppConstants.UserRole.Administrator } }
         };
         app.UseHangfireDashboard("/hangfire", dashboardOptions);


         var jobServerOptions = new BackgroundJobServerOptions
         {
            WorkerCount = 1
         };
         app.UseHangfireServer(jobServerOptions);

         RecurringJob.AddOrUpdate(() => UpdateDaemon.ScheduledCatalogsUpdate(), Cron.Hourly);
      }
Example #7
0
        public static void ConfigureHangfire(IAppBuilder app)
        {
            GlobalConfiguration.Configuration.UseSqlServerStorage("DefaultConnection");

            app.UseHangfireDashboard("/jobs");
            app.UseHangfireServer();
        }
Example #8
0
        public void Configuration(IAppBuilder app)
        {
            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            config.EnableSwagger("help/{apiVersion}", c =>
            {
                c.IncludeXmlComments("Slight.WeMo.Service.XML");
                c.SingleApiVersion("v1", "Slight.WeMo REST Api");
            }).EnableSwaggerUi("help/ui/{*assetPath}");
            app.UseWebApi(config);

            GlobalConfiguration.Configuration.UseMemoryStorage();
            app.UseHangfireDashboard("/hangfire", new DashboardOptions
            {
                AuthorizationFilters = new IAuthorizationFilter[] { new AllowAllFilter() }
            });
            app.UseHangfireServer();

            app.Use(async (context, func) =>
            {
                if (new[] { "/", "/help" }.Any(x => context.Request.Path.Value.StartsWith(x)))
                {
                    context.Response.Redirect("/help/ui/index");
                    return;
                }
                await func.Invoke();
            });
        }
Example #9
0
        public void Configuration(IAppBuilder app)
        {
            HangfireConfiguration.Register();

            var options = new DashboardOptions
            {
                AuthorizationFilters = new []
                {
                    new BasicAuthAuthorizationFilter(new BasicAuthAuthorizationFilterOptions
                    {
                        RequireSsl = true,
                        LoginCaseSensitive = true,
                        Users = new []
                        {
                            new BasicAuthAuthorizationUser
                            {
                                Login = "******",
                                PasswordClear = "D3v3L0pM3nT"
                            }
                        }
                    }),
                }
            };

            app.UseHangfireDashboard("/hangfire", options);
            app.UseHangfireServer();
        }
 public void Configuration(IAppBuilder app)
 {
     //Reference connection string for data base of hangfire
     GlobalConfiguration.Configuration.UseSqlServerStorage("myConnectionString");
     app.UseHangfireServer();
     //activate dashboard of hangfire in application
     app.UseHangfireDashboard();
 }
Example #11
0
        public void Configuration(IAppBuilder app)
        {
            GlobalConfiguration.Configuration
                .UseSqlServerStorage("CoopCheck");

            app.UseHangfireDashboard();
            app.UseHangfireServer();
        }
            public void Configuration(IAppBuilder app)
            {
                GlobalConfiguration.Configuration
                    .UseSqlServerStorage(@"<your_connection_string>");

                app.UseHangfireServer();
                app.UseHangfireDashboard();
            }
Example #13
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
            GlobalConfiguration.Configuration.UseSqlServerStorage("DefaultConnection");

            app.UseHangfireDashboard();
            app.UseHangfireServer();
        }
Example #14
0
        public void Configuration(IAppBuilder app)
        {
            string ConnectionString = ConfigurationManager.ConnectionStrings["dataSocket"].ConnectionString;
            ConfigureAuth(app);
            GlobalConfiguration.Configuration.UseSqlServerStorage(ConnectionString);

            app.UseHangfireDashboard();
            app.UseHangfireServer();
        }
Example #15
0
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();

            GlobalConfiguration.Configuration.UseMemoryStorage();

            app.UseHangfireDashboard();
            app.UseHangfireServer();
        }
        public void Configure(IAppBuilder appBuilder)
        {
            var dataProviderManager = EngineContext.Current.Resolve<BaseDataProviderManager>();
            Guard.NotNull(dataProviderManager);
            var connectionString = dataProviderManager.DataSettings.DataConnectionString;

            GlobalConfiguration.Configuration.UseSqlServerStorage(connectionString);
            appBuilder.UseHangfireDashboard();
            appBuilder.UseHangfireServer();
        }
Example #17
0
 public void Configuration(IAppBuilder app)
 {
     // 如需如何設定應用程式的詳細資訊,請參閱  http://go.microsoft.com/fwlink/?LinkID=316888
     // 指定Hangfire使用記憶體儲存任務
     GlobalConfiguration.Configuration.UseMemoryStorage();
     // 啟用HanfireServer
     app.UseHangfireServer();
     // 啟用Hangfire的Dashboard
     app.UseHangfireDashboard();
 }
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();

            GlobalConfiguration.Configuration.UseSqlServerStorage(
                "HighlighterDb",
                new SqlServerStorageOptions { QueuePollInterval = TimeSpan.FromSeconds(1) });

            app.UseHangfireDashboard();
            app.UseHangfireServer();
        }
Example #19
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);

            app.UseHangfireDashboard("/bkjobs", new DashboardOptions
            {
                AuthorizationFilters = new[] { new HangfireAuthorizationFilter() }
            });

            app.UseHangfireServer();
        }
        public void Configuration(IAppBuilder app)
        {
            GlobalConfiguration.Configuration
                .UseSqlServerStorage("data source=NIKOLAIRINC9DE5;initial catalog=HangfireDb;persist security info=True;user id=niki;password=123;application name=EntityFramework;MultipleActiveResultSets=True");

            app.UseHangfireDashboard("/hangfire", new DashboardOptions
            {
                AuthorizationFilters = new[] { new CookieAuthFilter () }
            });
            app.UseHangfireServer();
        }
Example #21
0
        // Config
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
            GlobalConfiguration.Configuration
               .UseSqlServerStorage("DefaultConnection");

            app.UseHangfireDashboard();
            app.UseHangfireServer();

            RecurringJob.AddOrUpdate("report",() => ToolConfigurationController.SendEmailReport(), Cron.Daily(13,00));
        }
Example #22
0
        public void Configuration(IAppBuilder app)
        {
            GlobalConfiguration.Configuration
                .UseSqlServerStorage(
                    "MailerDb",
                    new SqlServerStorageOptions { QueuePollInterval = TimeSpan.FromSeconds(1) })
                .UseFilter(new LogFailureAttribute());

            app.UseHangfireDashboard();
            app.UseHangfireServer();
        }
Example #23
0
        public void Configuration(IAppBuilder app)
        {
            GlobalConfiguration.Configuration.UseMemoryStorage();
            GlobalConfiguration.Configuration.UseNinjectActivator(NinjectWebCommon.kernel);

            app.UseHangfireDashboard();
            app.UseHangfireServer();
            var options = new BackgroundJobServerOptions();
            LogProvider.SetCurrentLogProvider(new RollbarLogProvider());
            RecurringJob.AddOrUpdate<SuperJob>(sb => sb.DoIt(), Cron.Minutely());
        }
        public void Configuration(IAppBuilder app)
        {
            ConnectionStringSettings connString;

            GlobalConfiguration.Configuration
            .UseLogProvider(new ColouredConsoleLogProvider())
            .UseSqlServerStorage(ConfigurationManager.ConnectionStrings["billingScheduler"].ConnectionString);

            app.UseHangfireServer();
            app.UseHangfireDashboard();
        }
Example #25
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureEnabledHangfireJobStorage(Settings.Default.JobStorageName);

            // Map Dashboard to the `http://<your-app>/jobs` URL.
            app.UseHangfireDashboard("/jobs");

            app.UseHangfireServer();

            LogProvider.SetCurrentLogProvider(new ElmahLogProvider(LogLevel.Info));
        }
Example #26
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
            GlobalConfiguration.Configuration.UseSqlServerStorage("DefaultConnection");

            app.MapSignalR(new HubConfiguration());
            app.UseHangfireDashboard();
            app.UseHangfireServer();

            RecurringJob.AddOrUpdate(() => _mono.SendPing(), Cron.Minutely());
        }
Example #27
0
        public void Configuration(IAppBuilder app)
        {           
            var Container = new ContainerBuilder();
            Container.RegisterAssemblyModules(typeof(MvcApplication).Assembly);
            var iContainer = Container.Build();
          
            app.UseHangfireDashboard();
            app.UseHangfireServer();

            taskProcessor = iContainer.Resolve<ITaskProcessor>();
        }
Example #28
0
        public void ConfigureHangfire(IAppBuilder app)
        {
            GlobalConfiguration.Configuration.UseMongoStorage("mongodb://localhost", "hangfire-mongo-sample");
            //GlobalConfiguration.Configuration.UseMongoStorage(new MongoClientSettings()
            //{
            //    // ...
            //    IPv6 = true
            //}, "hangfire-mongo-sample");

            app.UseHangfireServer();
            app.UseHangfireDashboard();
        }
Example #29
0
        public void Configuration(IAppBuilder app)
        {
            GlobalConfiguration.Configuration.UseSqlServerStorage(
                "DefaultConnection",
                new SqlServerStorageOptions { QueuePollInterval = TimeSpan.FromSeconds(1) });

            app.UseHangfireDashboard();
            app.UseHangfireServer();
            
            RecurringJob.AddOrUpdate(
                () => TextBuffer.WriteLine("Recurring Job completed successfully!"), 
                Cron.Minutely);
        }
Example #30
0
        public void Configuration(IAppBuilder app)
        {
            if (ConfigurationManagerHelper.GetValueOnKey("stardust.UseRealtimeUpdate") == "true")
            {
                app.MapSignalR();
                GlobalHost.HubPipeline.RequireAuthentication();
                RegisterForNotifications();
                return;
            }
            GlobalConfiguration.Configuration.UseStorage(new MemoryStorage());
            app.UseHangfireDashboard();
            app.UseHangfireServer();
            RecurringJob.AddOrUpdate("update", () => UpdateConfigSets(), () => string.Format("*/{0} * * * *", GetInterval()));

        }
        public void ConfigureHangfire(IAppBuilder app)
        {
            // Read DefaultConnection string from Web.config
            var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;

            var mongoOptions = new MongoStorageOptions
            {
                MigrationOptions = new MongoMigrationOptions
                {
                    MigrationStrategy = new MigrateMongoMigrationStrategy(),
                    BackupStrategy    = new CollectionMongoBackupStrategy()
                }
            };

            GlobalConfiguration.Configuration.UseMongoStorage(connectionString, mongoOptions);
            //GlobalConfiguration.Configuration.UseMongoStorage(new MongoClientSettings
            //{
            //    // ...
            //    IPv6 = true
            //}, "hangfire-mongo-sample");

            app.UseHangfireServer();
            app.UseHangfireDashboard();
        }
Example #32
0
        public void Configuration(IAppBuilder app)
        {
            var container = ConfigureBuilder().Build();
            var options   = new SqlServerStorageOptions
            {
                PrepareSchemaIfNecessary = false
            };

            GlobalConfiguration.Configuration.UseAutofacActivator(container).UseSqlServerStorage("DefaultConnection", options);
            if (Properties.Settings.Default.RunHangfireServer)
            {
                app.UseHangfireServer();
            }
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
            ConfigureAuth(app);
            if (Properties.Settings.Default.UseHangfireDashboards)
            {
                DashboardOptions dashboardOptionsoptions = new DashboardOptions
                {
                    Authorization = new[] { new HangfireDashboardAuthorizationFilter() }
                };
                app.UseHangfireDashboard("/hangfire", dashboardOptionsoptions);
            }
        }
Example #33
0
        public void Configuration(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();

            Hangfire.GlobalConfiguration.Configuration
            .UseSqlServerStorage("DefaultConnection");

            app.UseHangfireDashboard();
            app.UseHangfireServer();

            RecurringJob.AddOrUpdate(() => deleteOldCarts(), Cron.Daily);

            ConfigureAuth(app);
            //WebApiConfig.Register(config);
            app.UseCors(CorsOptions.AllowAll);
            app.UseWebApi(config);
            app.UseCookieAuthentication(new Microsoft.Owin.Security.Cookies.CookieAuthenticationOptions
            {
                AuthenticationType = "ApplicationCookie",
                LoginPath          = new PathString("/Home/SignIn"),
            });
            createRolesAndUsers();
            //ConfigureServices();
        }
        public override void Configuration(IAppBuilder app)
        {
            base.Configuration(app);

            // Configure the database where Hangfire is going to create its tables
            var cs = Umbraco.Core.ApplicationContext.Current.DatabaseContext.ConnectionString;

            GlobalConfiguration.Configuration
            .UseSqlServerStorage(cs);

            var dashboardOptions = new DashboardOptions
            {
                Authorization = new[]
                {
                    new UmbracoUserAuthorizationFilter()
                }
            };

            // Configure Hangfire's dashboard with auth configuration
            app.UseHangfireDashboard("/hangfire", dashboardOptions);

            // Create a default Hangfire server
            app.UseHangfireServer();
        }
Example #35
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);

            Log.Logger = new LoggerConfiguration().WriteTo.RollingFile(@"C:\Serilogs\RouteDelivery-{Date}.txt")
                         .CreateLogger();

            Log.Information("Route Delivery Started");

            GlobalConfiguration.Configuration.UseSqlServerStorage("HangfireR3");

            app.UseHangfireDashboard();

            var options = new BackgroundJobServerOptions
            {
                WorkerCount = 50
            };

            app.UseHangfireServer(options);

            //new BackgroundJobServer(options);

            DIConfig.Setup();
        }
Example #36
0
        public void Configuration(IAppBuilder app)
        {
            var config = new HttpConfiguration();

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{Controller}/{id}",
                defaults: new { id = RouteParameter.Optional });

            app.UseWebApi(config);

            app.UseRedis(ServerConfig.Config.DataBase.ConnectionString);

            app.UseNLog();

            app.UseHangfireServer(new BackgroundJobServerOptions
            {
                Queues = new[] { "critical", "default" },
            });

            app.UseHangfireDashboard();
        }
Example #37
0
 public void Configuration(IAppBuilder app)
 {
     GlobalConfiguration.Configuration.UseSqlServerStorage(@"Data Source=JAAN\SQLSERVER2017;Initial Catalog=DB_LMIGREATICE;Integrated Security=True");
     app.UseHangfireDashboard();
     app.UseHangfireServer();
 }
        public override void Configuration(IAppBuilder app)
        {
            //ensure the default options are configured
            base.Configuration(app);

            var clientId = WebConfigurationManager.AppSettings["GoogleOAuthClientID"];
            var secret   = WebConfigurationManager.AppSettings["GoogleOAuthSecret"];

            app.ConfigureBackOfficeGoogleAuth(clientId, secret);

            app.MapSignalR();

            if (string.Equals(ConfigurationManager.AppSettings["HangFireEnabled"], "true", StringComparison.InvariantCultureIgnoreCase) == false)
            {
                return;
            }

            // Configure hangfire
            var options = new SqlServerStorageOptions {
                PrepareSchemaIfNecessary = true
            };
            var connectionString = Umbraco.Core.ApplicationContext.Current.DatabaseContext.ConnectionString;

            GlobalConfiguration.Configuration
            .UseSqlServerStorage(connectionString, options)
            .UseConsole();


            var dashboardOptions = new DashboardOptions {
                Authorization = new[] { new UmbracoAuthorizationFilter() }
            };

            app.UseHangfireDashboard("/hangfire", dashboardOptions);
            app.UseHangfireServer();

            // Schedule jobs
            var scheduler = new ScheduleHangfireJobs();

            scheduler.MarkAsSolvedReminder();
            scheduler.UpdateGitHubContributors();
            scheduler.UpdateMeetupStats();
            scheduler.UpdateCommunityBlogPosts();
            scheduler.UpdateCommunityVideos();
            scheduler.UpdateVimeoVideos();
            scheduler.GetGitHubPullRequests();
            scheduler.RefreshKarmaStatistics();
            scheduler.GenerateReleasesCache(null);
            scheduler.UpdateGitHubIssues(null);
            scheduler.GetAllGitHubLabels(null);
            scheduler.AddCommentToAwaitingFeedbackIssues(null);
            scheduler.AddCommentToUpForGrabsIssues(null);
            scheduler.NotifyUnmergeablePullRequests(null);
            scheduler.AddCommentToStateHQDiscussionIssues(null);

            scheduler.CheckContributorBadge(null);

            //Hangfire jobs for Google Maps aka Radar
            var radarScheduler = new RadarHangfireJobs();

            radarScheduler.FindSignals();
        }
Example #39
0
        public void Configuration(IAppBuilder app)
        {
            AreaRegistration.RegisterAllAreas();
            System.Web.Http.GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);

            // Start unity
            UnityHelper.InitialiseUnityContainer();

            // Make DB update to latest migration
            Database.SetInitializer(new MigrateDatabaseToLatestVersion <MvcForumContext, Configuration>());

            // Set the rest of the Ioc
            UnityHelper.BuildUnityContainer();

            // Grab the container as we will need to use it
            var unityContainer = UnityHelper.Container;

            // Set Hangfire to use SQL Server and the connection string
            GlobalConfiguration.Configuration.UseSqlServerStorage(ForumConfiguration.Instance.MvcForumContext);

            // Make hangfire use unity container
            GlobalConfiguration.Configuration.UseUnityActivator(unityContainer);

            // Add Hangfire
            // TODO - Do I need this dashboard?
            //app.UseHangfireDashboard();
            app.UseHangfireServer();

            // Get services needed
            var mvcForumContext  = unityContainer.Resolve <IMvcForumContext>();
            var badgeService     = unityContainer.Resolve <IBadgeService>();
            var loggingService   = unityContainer.Resolve <ILoggingService>();
            var assemblyProvider = unityContainer.Resolve <IAssemblyProvider>();

            // Routes
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            // If the same carry on as normal
            var logFileSize = ForumConfiguration.Instance.LogFileMaxSizeBytes;

            loggingService.Initialise(logFileSize > 100000 ? logFileSize : 100000);
            loggingService.Error("START APP");

            // Find the plugin, pipeline and badge assemblies
            var assemblies = assemblyProvider.GetAssemblies(ForumConfiguration.Instance.PluginSearchLocations).ToList();

            ImplementationManager.SetAssemblies(assemblies);

            // Do the badge processing
            try
            {
                badgeService.SyncBadges(assemblies);
                mvcForumContext.SaveChanges();
            }
            catch (Exception ex)
            {
                loggingService.Error($"Error processing badge classes: {ex.Message}");
            }

            var theme    = "Metro";
            var settings = mvcForumContext.Setting.FirstOrDefault();

            if (settings != null)
            {
                theme = settings.Theme;
            }

            // Set the view engine
            ViewEngines.Engines.Clear();
            ViewEngines.Engines.Add(new ForumViewEngine(theme));

            // Initialise the events
            EventManager.Instance.Initialize(loggingService, assemblies);

            // Finally trigger any Cron jobs
            RecurringJob.AddOrUpdate <RecurringJobService>(x => x.SendMarkAsSolutionReminders(), Cron.HourInterval(6), queue: "solutionreminders");
        }
Example #40
0
        public void Configuration(IAppBuilder app)
        {
            // settings will automatically be used by JsonConvert.SerializeObject/DeserializeObject
            JsonConvert.DefaultSettings = () => new JsonSerializerSettings
            {
                Formatting       = Formatting.Indented,
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            };

            //
            // set database connection strings
            var connString = Settings.Default.ServerConnectionString;

            if (Debugger.IsAttached)
            {
                connString = Settings.Default.LocalConnectionString;
            }

            #region Configure NLog middleware

            app.UseNLog();
            LogProvider.SetCurrentLogProvider(new ColouredConsoleLogProvider());

            #endregion

            #region Configure Web API

            // Configure Web API for self-host.
            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            app.UseWebApi(config);

            #endregion

            #region Configure Hangfire Background Worker

            // Configure AppDomain parameter to simplify the Configure – http://stackoverflow.com/a/3501950/1317575
            AppDomain.CurrentDomain.SetData("DataDirectory",
                                            Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data"));

            var script = FileManager.ReadResourceFile(Settings.Default.HangfireDbScript);
            var cm     = new ConnectionManager(new Connection(connString));
            cm.CreateDatabaseIfNotExist(script);

            GlobalConfiguration.Configuration.UseSqlServerStorage(connString,
                                                                  new SqlServerStorageOptions {
                QueuePollInterval = TimeSpan.FromSeconds(30)
            })
            .UseFilter(new LogEverythingAttribute());

            app.UseHangfireDashboard("/hangfire");
            app.UseHangfireServer(new BackgroundJobServerOptions
            {
                ServerCheckInterval = TimeSpan.FromSeconds(30),
                HeartbeatInterval   = TimeSpan.FromSeconds(5)
                                      /*ServerName = "Hasin_Hangfire"*/
            }, JobStorage.Current);

            // Read and start jobs
            JobsManager.CheckupSetting(Settings.Default.SettingFileName, 100);

            #endregion


            // Alert all notify receivers to know TaskScheduler restarted
            if (JobsManager.Setting?.Notifications?.Any() == true)
            {
                foreach (var notify in JobsManager.Setting.Notifications)
                {
                    notify.Notify("`Application successful running...`", "Task Scheduler {version}");
                }
            }
        }
Example #41
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // DataContext
            builder.RegisterType <GridDataContext>().As <GridDataContext>().As <IDbContext>().InstancePerRequest();
            builder.RegisterType <UnitOfWork>().As <IUnitOfWork>().InstancePerRequest();

            // Repositories

            // Attendance
            builder.RegisterType <AttendanceRepository>().As <IAttendanceRepository>().InstancePerRequest();

            // Auth
            builder.RegisterType <TokenRepository>().As <ITokenRepository>().InstancePerRequest();

            //Company
            builder.RegisterType <AwardRepository>().As <IAwardRepository>().InstancePerRequest();
            builder.RegisterType <EmailTemplateRepository>().As <IEmailTemplateRepository>().InstancePerRequest();
            builder.RegisterType <LocationRepository>().As <ILocationRepository>().InstancePerRequest();
            builder.RegisterType <PermissionRepository>().As <IPermissionRepository>().InstancePerRequest();
            builder.RegisterType <RoleMemberRepository>().As <IRoleMemberRepository>().InstancePerRequest();
            builder.RegisterType <RolePermissionRepository>().As <IRolePermissionRepository>().InstancePerRequest();
            builder.RegisterType <RoleRepository>().As <IRoleRepository>().InstancePerRequest();
            builder.RegisterType <TechnologyRepository>().As <ITechnologyRepository>().InstancePerRequest();

            // CRM
            builder.RegisterType <CRMAccountRepository>().As <ICRMAccountRepository>().InstancePerRequest();
            builder.RegisterType <CRMContactRepository>().As <ICRMContactRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadActivityRepository>().As <ICRMLeadActivityRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadCategoryRepository>().As <ICRMLeadCategoryRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadRepository>().As <ICRMLeadRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadSourceRepository>().As <ICRMLeadSourceRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadStatusRepository>().As <ICRMLeadStatusRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadTechnologyMapRepository>().As <ICRMLeadTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialActivityRepository>().As <ICRMPotentialActivityRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialCategoryRepository>().As <ICRMPotentialCategoryRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialRepository>().As <ICRMPotentialRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialTechnologyMapRepository>().As <ICRMPotentialTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <CRMSalesStageRepository>().As <ICRMSalesStageRepository>().InstancePerRequest();

            //HRMS
            builder.RegisterType <AccessRuleRepository>().As <IAccessRuleRepository>().InstancePerRequest();
            builder.RegisterType <CertificationRepository>().As <ICertificationRepository>().InstancePerRequest();
            builder.RegisterType <DepartmentRepository>().As <IDepartmentRepository>().InstancePerRequest();
            builder.RegisterType <DesignationRepository>().As <IDesignationRepository>().InstancePerRequest();
            builder.RegisterType <EmergencyContactRepository>().As <IEmergencyContactRepository>().InstancePerRequest();
            builder.RegisterType <EmployeeDependentRepository>().As <IEmployeeDependentRepository>().InstancePerRequest();
            builder.RegisterType <HobbyRepository>().As <IHobbyRepository>().InstancePerRequest();
            builder.RegisterType <LinkedAccountRepository>().As <ILinkedAccountRepository>().InstancePerRequest();
            builder.RegisterType <PersonRepository>().As <IPersonRepository>().InstancePerRequest();
            builder.RegisterType <ShiftRepository>().As <IShiftRepository>().InstancePerRequest();
            builder.RegisterType <SkillRepository>().As <ISkillRepository>().InstancePerRequest();
            builder.RegisterType <UserActivityRepository>().As <IUserActivityRepository>().InstancePerRequest();
            builder.RegisterType <UserAwardRepository>().As <IUserAwardRepository>().InstancePerRequest();
            builder.RegisterType <UserCertificationRepository>().As <IUserCertificationRepository>().InstancePerRequest();
            builder.RegisterType <UserDocumentRepository>().As <IUserDocumentRepository>().InstancePerRequest();
            builder.RegisterType <UserHobbyRepository>().As <IUserHobbyRepository>().InstancePerRequest();
            builder.RegisterType <UserRepository>().As <IUserRepository>().InstancePerRequest();
            builder.RegisterType <UserSkillRepository>().As <IUserSkillRepository>().InstancePerRequest();
            builder.RegisterType <UserTechnologyMapRepository>().As <IUserTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <EmployeeRepository>().As <IEmployeeRepository>().InstancePerRequest();


            // IMS
            builder.RegisterType <AssetAllocationRepository>().As <IAssetAllocationRepository>().InstancePerRequest();
            builder.RegisterType <AssetCategoryRepository>().As <IAssetCategoryRepository>().InstancePerRequest();
            builder.RegisterType <AssetDocumentRepository>().As <IAssetDocumentRepository>().InstancePerRequest();
            builder.RegisterType <AssetRepository>().As <IAssetRepository>().InstancePerRequest();
            builder.RegisterType <VendorRepository>().As <IVendorRepository>().InstancePerRequest();

            // IT
            builder.RegisterType <SoftwareCategoryRepository>().As <ISoftwareCategoryRepository>().InstancePerRequest();
            builder.RegisterType <SoftwareRepository>().As <ISoftwareRepository>().InstancePerRequest();
            builder.RegisterType <SystemSnapshotRepository>().As <ISystemSnapshotRepository>().InstancePerRequest();

            // KBS
            builder.RegisterType <ArticleAttachmentRepository>().As <IArticleAttachmentRepository>().InstancePerRequest();
            builder.RegisterType <ArticleRepository>().As <IArticleRepository>().InstancePerRequest();
            builder.RegisterType <ArticleVersionRepository>().As <IArticleVersionRepository>().InstancePerRequest();
            builder.RegisterType <CategoryRepository>().As <ICategoryRepository>().InstancePerRequest();
            builder.RegisterType <KeywordRepository>().As <IKeywordRepository>().InstancePerRequest();

            // LMS
            builder.RegisterType <HolidayRepository>().As <IHolidayRepository>().InstancePerRequest();
            builder.RegisterType <LeaveEntitlementRepository>().As <ILeaveEntitlementRepository>().InstancePerRequest();
            builder.RegisterType <LeaveEntitlementUpdateRepository>().As <ILeaveEntitlementUpdateRepository>().InstancePerRequest();
            builder.RegisterType <LeaveRepository>().As <ILeaveRepository>().InstancePerRequest();
            builder.RegisterType <LeaveTimePeriodRepository>().As <ILeaveTimePeriodRepository>().InstancePerRequest();
            builder.RegisterType <LeaveTypeRepository>().As <ILeaveTypeRepository>().InstancePerRequest();

            // Payroll
            builder.RegisterType <EmployeeSalaryRepository>().As <IEmployeeSalaryRepository>().InstancePerRequest();
            builder.RegisterType <SalaryComponentRepository>().As <ISalaryComponentRepository>().InstancePerRequest();

            //PMS
            builder.RegisterType <ProjectBillingRepository>().As <IProjectBillingRepository>().InstancePerRequest();
            builder.RegisterType <ProjectBillingCorrectionRepository>().As <IProjectBillingCorrectionRepository>().InstancePerRequest();
            builder.RegisterType <ProjectDocumentRepository>().As <IProjectDocumentRepository>().InstancePerRequest();
            builder.RegisterType <ProjectMemberRepository>().As <IProjectMemberRepository>().InstancePerRequest();
            builder.RegisterType <ProjectMileStoneRepository>().As <IProjectMileStoneRepository>().InstancePerRequest();
            builder.RegisterType <ProjectRepository>().As <IProjectRepository>().InstancePerRequest();
            builder.RegisterType <ProjectActivityRepository>().As <IProjectActivityRepository>().InstancePerRequest();
            builder.RegisterType <ProjectTechnologyMapRepository>().As <IProjectTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <TaskEffortRepository>().As <ITaskEffortRepository>().InstancePerRequest();
            builder.RegisterType <TaskRepository>().As <ITaskRepository>().InstancePerRequest();
            builder.RegisterType <TimeSheetLineItemRepository>().As <ITimeSheetLineItemRepository>().InstancePerRequest();
            builder.RegisterType <TimeSheetRepository>().As <ITimeSheetRepository>().InstancePerRequest();
            builder.RegisterType <EstimateRepository>().As <IEstimateRepository>().InstancePerRequest();
            builder.RegisterType <EstimateLineItemRepository>().As <IEstimateLineItemRepository>().InstancePerRequest();
            builder.RegisterType <TimeSheetActivityRepository>().As <ITimeSheetActivityRepository>().InstancePerRequest();
            builder.RegisterType <TaskActivityRepository>().As <ITaskActivityRepository>().InstancePerRequest();
            builder.RegisterType <ProjectMemberRoleRepository>().As <IProjectMemberRoleRepository>().InstancePerRequest();


            //Recruit
            builder.RegisterType <CandidateActivityRepository>().As <ICandidateActivityRepository>().InstancePerRequest();
            builder.RegisterType <CandidateDesignationRepository>().As <ICandidateDesignationRepository>().InstancePerRequest();
            builder.RegisterType <CandidateDocumentRepository>().As <ICandidateDocumentRepository>().InstancePerRequest();
            builder.RegisterType <CandidateRepository>().As <ICandidateRepository>().InstancePerRequest();
            builder.RegisterType <CandidateTechnologyMapRepository>().As <ICandidateTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <InterviewRoundRepository>().As <IInterviewRoundRepository>().InstancePerRequest();
            builder.RegisterType <InterviewRoundActivityRepository>().As <IInterviewRoundActivityRepository>().InstancePerRequest();
            builder.RegisterType <InterviewRoundDocumentRepository>().As <IInterviewRoundDocumentRepository>().InstancePerRequest();
            builder.RegisterType <JobOfferRepository>().As <IJobOfferRepository>().InstancePerRequest();
            builder.RegisterType <JobOpeningRepository>().As <IJobOpeningRepository>().InstancePerRequest();
            builder.RegisterType <ReferalRepository>().As <IReferalRepository>().InstancePerRequest();
            builder.RegisterType <RoundRepository>().As <IRoundRepository>().InstancePerRequest();

            // RMS
            builder.RegisterType <RequirementActivityRepository>().As <IRequirementActivityRepository>().InstancePerRequest();
            builder.RegisterType <RequirementCategoryRepository>().As <IRequirementCategoryRepository>().InstancePerRequest();
            builder.RegisterType <RequirementDocumentRepository>().As <IRequirementDocumentRepository>().InstancePerRequest();
            builder.RegisterType <RequirementRepository>().As <IRequirementRepository>().InstancePerRequest();
            builder.RegisterType <RequirementTechnologyMapRepository>().As <IRequirementTechnologyMapRepository>().InstancePerRequest();

            // Settings
            builder.RegisterType <GridUpdateRepository>().As <IGridUpdateRepository>().InstancePerRequest();
            builder.RegisterType <SettingRepository>().As <ISettingRepository>().InstancePerRequest();
            builder.RegisterType <UserFeedbackRepository>().As <IUserFeedbackRepository>().InstancePerRequest();
            builder.RegisterType <ApplicationRepository>().As <IApplicationRepository>().InstancePerRequest();

            // TicketDesk
            builder.RegisterType <TicketCategoryRepository>().As <ITicketCategoryRepository>().InstancePerRequest();
            builder.RegisterType <TicketSubCategoryRepository>().As <ITicketSubCategoryRepository>().InstancePerRequest();
            builder.RegisterType <TicketRepository>().As <ITicketRepository>().InstancePerRequest();
            builder.RegisterType <TicketActivityRepository>().As <ITicketActivityRepository>().InstancePerRequest();

            // TMS
            builder.RegisterType <MissedTimeSheetRepository>().As <IMissedTimeSheetRepository>().InstancePerRequest();

            //Social
            builder.RegisterType <PostRepository>().As <IPostRepository>().InstancePerRequest();
            builder.RegisterType <PostCommentRepository>().As <IPostCommentRepository>().InstancePerRequest();
            builder.RegisterType <PostLikeRepository>().As <IPostLikeRepository>().InstancePerRequest();

            // Business Services
            builder.RegisterType <CRMLeadService>().As <ICRMLeadService>().InstancePerRequest();
            builder.RegisterType <CRMPotentialService>().As <ICRMPotentialService>().InstancePerRequest();
            builder.RegisterType <CRMAccountService>().As <ICRMAccountService>().InstancePerRequest();
            builder.RegisterType <CRMContactService>().As <ICRMContactService>().InstancePerRequest();

            builder.RegisterType <RequirementService>().As <IRequirementService>().InstancePerRequest();
            builder.RegisterType <SettingsService>().As <ISettingsService>().InstancePerRequest();
            builder.RegisterType <UserService>().As <IUserService>().InstancePerRequest();
            builder.RegisterType <AssetService>().As <IAssetService>().InstancePerRequest();
            builder.RegisterType <LeaveService>().As <ILeaveService>().InstancePerRequest();
            builder.RegisterType <CandidateService>().As <ICandidateService>().InstancePerRequest();
            builder.RegisterType <RequirementService>().As <IRequirementService>().InstancePerRequest();
            builder.RegisterType <SettingsService>().As <ISettingsService>().InstancePerRequest();
            builder.RegisterType <TicketService>().As <ITicketService>().InstancePerRequest();
            builder.RegisterType <TimeSheetService>().As <ITimeSheetService>().InstancePerRequest();
            builder.RegisterType <TaskService>().As <ITaskService>().InstancePerRequest();
            builder.RegisterType <InterviewRoundService>().As <IInterviewRoundService>().InstancePerRequest();

            // Common Services
            builder.RegisterType <NotificationService>().As <INotificationService>().InstancePerRequest();
            builder.RegisterType <EmailComposerService>().As <EmailComposerService>().InstancePerRequest();

            // Register your MVC controllers.
            builder.RegisterControllers(typeof(MvcApplication).Assembly);
            builder.RegisterControllers(typeof(ApiAreaRegistration).Assembly);
            builder.RegisterApiControllers(typeof(GenericApiAreaRegistration).Assembly);

            // Register Injection for Filters
            builder.Register(c => new GlobalIdentityInjector(c.Resolve <IUserRepository>(), c.Resolve <IRoleMemberRepository>(), c.Resolve <IRolePermissionRepository>())).AsActionFilterFor <Controller>().InstancePerRequest();
            builder.RegisterFilterProvider();


            builder.Register(c => new GridApiAuthenticationFilter(c.Resolve <IUserRepository>(), c.Resolve <IRoleMemberRepository>(), c.Resolve <IRolePermissionRepository>())).AsWebApiAuthorizationFilterFor <ApiController>();
            builder.RegisterWebApiFilterProvider(System.Web.Http.GlobalConfiguration.Configuration);

            builder.RegisterType <SubDomainTenantIdentificationStrategy>().As <ITenantIdentificationStrategy>();

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);


            // Register the Autofac middleware FIRST, then the Autofac MVC middleware.
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            GlobalConfiguration.Configuration.UseSqlServerStorage("Grid");
            app.UseHangfireDashboard("/jobqueue", new DashboardOptions
            {
                Authorization = new[] { new HangfireAuthorizationFilter() }
            });
            app.UseHangfireServer();


            // SignalR
            GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new GridSignalRUserIdProvider());
            app.MapSignalR();
        }
Example #42
0
        public void Configuration(IAppBuilder app)
        {
            var ioc = UnityConfig.Container;

            // Setup Hangfire
            GlobalConfiguration
            .Configuration
            .UseStorage(new MySqlStorage("DefaultHangfireConnection"));

            GlobalConfiguration
            .Configuration
            .UseActivator(new ContainerJobActivator(UnityConfig.ContainerHangfire));

            var options = new DashboardOptions
            {
                AuthorizationFilters = new List <IAuthorizationFilter>
                {
                    new AuthorizationFilter {
                        Roles = "Admin"
                    },
                    new ClaimsBasedAuthorizationFilter("name", "value")
                }
            };

            app.UseHangfireDashboard("/hangfire", options);
            app.UseHangfireServer();

            // Configure the db context to use a single instance per request
            app.CreatePerOwinContext(() =>
            {
                return(ioc.Resolve <ApplicationDbContext>());
            });

            // Configure the signin manager to use a single instance per request
            app.CreatePerOwinContext <UserManagerService>((o, c) =>
            {
                var u = ioc.Resolve <IUserStore <ApplicationUser> >();

                var m = new UserManagerService(
                    u,
                    o,
                    ioc.Resolve <IIdentityMessageService>("IdentityMsgSvcEmail"),
                    ioc.Resolve <IIdentityMessageService>("IdentityMsgSvcSMS"),
                    ioc.Resolve <ISettingsService>());
                return(m);
            });

            // Configure the user manager to use a single instance per request
            app.CreatePerOwinContext <SignInManagerService>((o, c) =>
            {
                var m = new SignInManagerService(
                    c.GetUserManager <UserManagerService>(),
                    c.Authentication,
                    ioc.Resolve <ISettingsService>());

                return(m);
            });

            var authorizationService = ioc.Resolve <IAuthorizationService>();

            authorizationService.Setup(app);

            // Use hangfire to fetch data periodically
            RecurringJob.AddOrUpdate(
                "MovieListUpdateService",
                () => RunMovieListUpdateService(new Hangfire.JobCancellationToken(false)),
                Cron.Daily
                );
        }
Example #43
0
        /// <summary>
        /// Host the Historian API
        /// </summary>
        /// <param name="app">The App Builder to use</param>
        /// <param name="options">The options for setting up the API</param>
        public static void UseHistorianApi(this IAppBuilder app, HistorianApiOptions options)
        {
            // check inputs
            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            // get logger type
            var loggerInstance = (IStartableLogger)Activator.CreateInstance(options.LoggerType, options.LoggerConfiguration);

            // start logger
            loggerInstance.Start();

            // read app properties
            var properties = new AppProperties(app.Properties);

            // get cancellation token
            var token = properties.OnAppDisposing;

            // if we have one
            if (token != CancellationToken.None)
            {
                // register callback to shutdown stuff
                token.Register(() =>
                {
                    // stop logger
                    loggerInstance.Stop();
                });
            }

            // Configure Web API for self-host.
            var webApiConfig = new HttpConfiguration();

            WebApiConfig.Register(webApiConfig);

            // setup hangfire
            if (options.UseHangFire)
            {
                // turn on hangfire for message drop
                MessageDrop.HangFireEnabled = true;

                // get hangfire connection string
                var hangFireConnectionInfo = options.HangFireConnectionString;

                // setup hangfire storage
                Hangfire.GlobalConfiguration.Configuration
                .UseSqlServerStorage(hangFireConnectionInfo);

                // show dashboard
                app.UseHangfireDashboard();

                // setup hangfire server
                app.UseHangfireServer(new BackgroundJobServerOptions()
                {
                    // setup the queues
                    Queues = new[]
                    {
                        "message_drop"
                    },

                    // set good
                    WorkerCount = 4
                });
            }

            // setup webapi to use NInject
            app.UseNinjectMiddleware(() => CreateKernel(loggerInstance)).UseNinjectWebApi(webApiConfig);
        }
 public void Configuration(IAppBuilder app)
 {
     ConfigureAuth(app);
     GlobalConfiguration.Configuration.UseSqlServerStorage(System.Configuration.ConfigurationManager.ConnectionStrings["DBConnection"].ConnectionString);
     app.UseHangfireServer();
 }
Example #45
0
        /// <summary>
        /// Configuration.
        /// </summary>
        /// <param name="app"></param>
        public void Configuration(IAppBuilder app)
        {
            // Load the configuration
            IConfigurationService configurationService = new JsonConfigurationService($"{Environment.CurrentDirectory}/config.json");

            string hangfireConnectionString = ConfigurationManager.ConnectionStrings["Hangfire"].ConnectionString;

            Log.Information("Hangfire connection string {hangfireConnection}", hangfireConnectionString);


            // Autofac API container
            var apiContainerBuilder = new ContainerBuilder();

            apiContainerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            apiContainerBuilder.RegisterType <SendDocumentsJob>();
            apiContainerBuilder.RegisterType <StoreAndForwardDbContext>().AsSelf()
            .OnActivating(d => Log.Information("OnActivating - StoreAndForwardDbContext"))
            .OnRelease(d =>     // Uses Autofac automatic disposal for the DB context
            {
                Log.Information("OnRelease - StoreAndForwardDbContext");
                d.Dispose();
            });

            apiContainerBuilder.RegisterType <QueueManager>().As <IQueueManager>()
            .WithParameter("retryLimit", configurationService.RetryLimit);
            apiContainerBuilder.RegisterType <DataStore>().As <IDataStore>();
            apiContainerBuilder.RegisterType <SignalrNotificationService>().As <INotificationService>();
            apiContainerBuilder.RegisterType <CdaPackageService>().As <ICdaPackageService>();
            apiContainerBuilder.RegisterType <MhrDocumentUploadClient>().As <IMhrDocumentUploadClient>();
            apiContainerBuilder.RegisterType <MhrDocumentUploadClient>().As <IMhrDocumentUploadClient>()
            .WithParameter("endpoint", configurationService.UploadDocumentEndpoint)
            .WithParameter("certificate", configurationService.Certificate)
            .WithParameter("facilityType", configurationService.HealthcareFacility)
            .WithParameter("practiceSetting", configurationService.PracticeSetting)
            .WithParameter("clientSystem", configurationService.ClientSystemType)
            .WithParameter("productInfo", configurationService.ProductInfo);

            // HTTP configuration
            var httpConfiguration = new HttpConfiguration();

            httpConfiguration.MapHttpAttributeRoutes();
            httpConfiguration.Formatters.Remove(httpConfiguration.Formatters.XmlFormatter);
            httpConfiguration.Formatters.Add(httpConfiguration.Formatters.JsonFormatter);
            httpConfiguration.Services.Replace(typeof(IExceptionHandler), new StoreAndForwardExceptionHandler());

            //config.EnableSystemDiagnosticsTracing();
            SystemDiagnosticsTraceWriter diagnosticsTraceWriter = new SystemDiagnosticsTraceWriter
            {
                MinimumLevel = TraceLevel.Off,
                IsVerbose    = true
            };

            httpConfiguration.Services.Replace(typeof(ITraceWriter), (object)diagnosticsTraceWriter);
            httpConfiguration.MessageHandlers.Add(new SerilogLoggingMessageHandler());

            // OpenAPI
            httpConfiguration.EnableSwagger(c =>
            {
                c.SingleApiVersion("v1", "Store and Forward API");
                c.IncludeXmlComments(GetXmlCommentsPath());
                c.RootUrl(r => $"{r.RequestUri.Scheme}://{r.RequestUri.Authority}/storeandforward");
            })
            .EnableSwaggerUi(c =>
            {
                c.DisableValidator();     // Prevent Swashbuckle using external validation
            });

            var apiContainer = apiContainerBuilder.Build();

            httpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(apiContainer);

            // Hangfire setup
            GlobalConfiguration.Configuration
            .UseSqlServerStorage(hangfireConnectionString)
            .UseAutofacActivator(apiContainer);

            // Setup CORS
            var corsPolicy = new CorsPolicy
            {
                AllowAnyMethod      = true,
                AllowAnyHeader      = true,
                AllowAnyOrigin      = true,
                SupportsCredentials = false
            };

            var corsOptions = new CorsOptions
            {
                PolicyProvider = new CorsPolicyProvider
                {
                    PolicyResolver = context => Task.FromResult(corsPolicy)
                }
            };

            app.UseCors(corsOptions);

            // Add SignalR
            app.MapSignalR();

            app.UseHangfireDashboard("/hangfire", new DashboardOptions
            {
                // Allow all IPs to connect
                Authorization = new[] { new DebugHangfireDashboardAuthorizationFilter() }
            });
            app.UseHangfireServer();

            // Web API
            app.UseAutofacMiddleware(apiContainer);
            app.UseAutofacWebApi(httpConfiguration);
            app.UseWebApi(httpConfiguration);

            // Create a recurring job
            RecurringJob.AddOrUpdate <SendDocumentsJob>(c => c.Execute(), Cron.MinuteInterval(configurationService.SendIntervalInMinutes));
        }
Example #46
0
 public void Configuration(IAppBuilder app)
 {
     GlobalConfiguration.Configuration.UseSqlServerStorage("HangFireDbConnection");
     app.UseHangfireDashboard();
     app.UseHangfireServer();
 }
Example #47
0
        /// <summary>
        /// The configuration.
        /// </summary>
        /// <param name="app">
        /// The app.
        /// </param>
        public void Configuration(IAppBuilder app)
        {
            var options      = GetDscManagerOptions();
            var httpListener = (HttpListener)app.Properties["System.Net.HttpListener"];

            httpListener.AuthenticationSchemes = AuthenticationSchemes.Ntlm | AuthenticationSchemes.Anonymous;

            // Set up DI
            var containerBuilder = RegisterTypes(options);

            containerBuilder.RegisterInstance(options).AsImplementedInterfaces();

            // Register types for components
            containerBuilder.RegisterNodeRepositoryTypes(options.NodeRepositoryOptions);
            containerBuilder.RegisterDeploymentServerTypes(options.DeploymentServerOptions);
            containerBuilder.RegisterReportingEndpointTypes(options.ReportingEndpointOptions);

            // Build container
            var container = containerBuilder.Build();

            Container = container;

            // Initialize DB
            MigrationsContextFactory.NameOrConnectionString = "DscManager";
            var logging = container.Resolve <IDscManagerLogging>();

            Database.SetInitializer(new DscManagerContextInitializer(logging));

            var context = container.Resolve <DscManagerContext>();

            context.Database.Initialize(true);
            var init = container.Resolve <IDataInitializer>();

            if (init.ShouldRunInitializer())
            {
                init.Initialize();
            }
            context.Dispose();

            // Configure HangFire
            GlobalConfiguration.Configuration.UseSqlServerStorage("DscManager");
            GlobalConfiguration.Configuration.UseAutofacActivator(container);
            if (options.UseJobDashboard)
            {
                app.UseHangfireDashboard();
            }

            this.SetupDbCleanup();

            if (options.UseHangfireJobServer)
            {
                var jobServerOptions = new BackgroundJobServerOptions
                {
                    Queues      = new[] { "mofbuilder" },
                    WorkerCount = options.WorkerCount
                };
                app.UseHangfireServer(jobServerOptions);
            }

            var hangfireOptions = new BackgroundJobServerOptions
            {
                Queues      = new[] { "priority", "default" },
                WorkerCount = 10
            };

            app.UseHangfireServer(hangfireOptions);

            // Resolve ViewModelFactory so we have an instance
            container.Resolve <IViewModelFactory>();

            // Set up config
            var config = container.Resolve <HttpConfiguration>();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            config.MessageHandlers.Add(new UrlHelperHandler(container.ComponentRegistry));

            // Filters
            var p = container.Resolve <IEnvironmentProperties>();

            if (!p.DebuggerAttached)
            {
                config.Filters.Add(new AuthorizeAttribute());
            }
            config.MessageHandlers.Add(new AuthenticationHandler(container, container.Resolve <IDscManagerLogging>()));

            // Formatters
            config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            config.Formatters.JsonFormatter.SerializerSettings.Formatting            = Formatting.Indented;

            config.Formatters.Add(new JsonTextMediaFormatter());

            // Policies
            config.IncludeErrorDetailPolicy = options.ErrorDetailPolicy;

            // Routes
            config.MapHttpAttributeRoutes(new CentralizedPrefixProvider("api/v{version:int}"));

            // Set up components
            app.UseNodeRepositoryComponent(container);
            app.UseDeploymentServerComponent(container);
            app.UseReportingEndpointComponent(container);

            app.UseCredentialRepository(options.CredentialRepositoryOptions);

            // Set up event infrastructure
            var eventHandlers = container.Resolve <IEnumerable <IDscEventHandler> >();

            foreach (var handler in eventHandlers)
            {
                handler.Start();
            }

            // Set up middleware
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            if (options.UseApi)
            {
                app.UseWebApi(config);
            }


            config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
            config.EnsureInitialized();

            container.Resolve <IDscManagerLogging>().Start();
        }
Example #48
0
 public void Configuration(IAppBuilder app)
 {
     GlobalConfiguration.Configuration.UseSqlServerStorage("ProjectContext");
     app.UseHangfireDashboard();
     app.UseHangfireServer();
 }
Example #49
0
        //public void ConfigureServices(IServiceCollection services)
        //{
        //   services.AddMemoryCache();
        //   //services.AddMvc();
        //}

        public void Configuration(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();

            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

            app.CreatePerOwinContext <AppIdentityDbContext>(AppIdentityDbContext.Create);
            app.CreatePerOwinContext <AppUserManager>(AppUserManager.Create);

            OAuthAuthorizationServerOptions OAuthServerOptions = new OAuthAuthorizationServerOptions()
            {
                AllowInsecureHttp         = true,
                TokenEndpointPath         = new PathString("/api/tap/token"),
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(1.1),
                Provider = new SimpleAuthorizationServerProvider(AppIdentityDbContext.Create)
            };

            // Token Generation

            app.UseOAuthAuthorizationServer(OAuthServerOptions);
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions
            {
                Provider = new OAuthBearerAuthenticationProvider()
            });

            WebApiConfig.Register(config);

            app.UseWebApi(config);

            // MVC Authentication

            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/account/login"),
                ExpireTimeSpan     = TimeSpan.FromDays(30),
                SlidingExpiration  = true
            });

            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
            app.UseSteamAuthentication(System.Configuration.ConfigurationManager.AppSettings["steamAPIKey"]);

            Hangfire.GlobalConfiguration.Configuration.UseSqlServerStorage("AppIdentityDbContext");
            var auth = new Hangfire.Dashboard.AuthorizationFilter()
            {
                Users = "Monukai", Roles = "Admin"
            };

            //var options = new BackgroundJobServerOptions { WorkerCount = 1 };
            app.UseHangfireDashboard("/hangfire", new DashboardOptions {
                Authorization = new[] { new HangfireAuthorizationFilter()
                                        {
                                            Roles = new List <String> {
                                                "Admin"
                                            }
                                        } }
            });

            app.UseHangfireServer();

            TaskRegister.RegisterAuctions();
            TaskRegister.RegisterGiveaways();
            TaskRegister.RegisterDailyTasks();
        }
Example #50
0
        public void Configuration(IAppBuilder app)
        {
            // Configure Web API for self-host.
            HttpConfiguration config = new HttpConfiguration();

            config.MapHttpAttributeRoutes();

            config.EnableSwagger(c =>
            {
                c.SingleApiVersion("v1", "Hangfire Topshelf Apis");
                c.IncludeXmlComments($@"{typeof(Startup).Assembly.GetName().Name}.xml");
            })
            .EnableSwaggerUi();

            var container = app.UseAutofac(config);

            app.UseWebApi(config);

            var queues = new[] { "default", "apis", "jobs" };

#if DEBUG
            app.UseStorage(new Hangfire.SqlServer.SqlServerStorage(HangfireSettings.Instance.HangfireSqlserverConnectionString))
            // .UseMsmq(@".\private$\hangfire-{0}", queues)
            .UseConsole();
#else
            app.UseStorage(new Hangfire.Redis.RedisStorage(HangfireSettings.Instance.HangfireRedisConnectionString))
            .UseConsole();
            //it seems a bug that progress bar in Hangfire.Console cannot dispaly for a long time when using redis storage.
#endif

            //global hangfire filters
            app.UseHangfireFilters(new AutomaticRetryAttribute {
                Attempts = 0
            });

            app.UseHangfireServer(new BackgroundJobServerOptions
            {
                //wait all jobs performed when BackgroundJobServer shutdown.
                ShutdownTimeout = TimeSpan.FromMinutes(30),
                Queues          = queues,
                WorkerCount     = Math.Max(Environment.ProcessorCount, 20)
            });
            var options = new DashboardOptions
            {
                AppPath = HangfireSettings.Instance.AppWebSite,
                AuthorizationFilters = new[]
                {
                    new BasicAuthAuthorizationFilter(new BasicAuthAuthorizationFilterOptions
                    {
                        SslRedirect        = false,
                        RequireSsl         = false,
                        LoginCaseSensitive = true,
                        Users = new[]
                        {
                            new BasicAuthAuthorizationUser
                            {
                                Login = HangfireSettings.Instance.LoginUser,
                                // Password as plain text
                                PasswordClear = HangfireSettings.Instance.LoginPwd
                            }
                        }
                    })
                }
            };
            app.UseHangfireDashboard("", options);

            app.UseDashboardMetric();

            //app.UseRecurringJob(typeof(RecurringJobService));

            app.UseRecurringJob(container);

            //app.UseRecurringJob("recurringjob.json");
        }
Example #51
0
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);

            //HangFire Configuration Begins
            GlobalConfiguration.Configuration.UseSqlServerStorage("ConStr");

            DataCollection.AutomaticBackup AutoBackup = new DataCollection.AutomaticBackup();//instantiating back up class

            //Scheduling background backups
            RecurringJob.AddOrUpdate(() => AutoBackup.backupQuestionPapersDump(), "0 5/12 * * *", TimeZoneInfo.FindSystemTimeZoneById("India Standard Time"));
            RecurringJob.AddOrUpdate(() => AutoBackup.backupPapers(), "0 5/12 * * *", TimeZoneInfo.FindSystemTimeZoneById("India Standard Time"));
            RecurringJob.AddOrUpdate(() => AutoBackup.backupCAPapers(), "0 5/12 * * *", TimeZoneInfo.FindSystemTimeZoneById("India Standard Time"));                   //cron for backing up twice a day
            RecurringJob.AddOrUpdate(() => AutoBackup.backupHardPapers(), "0 5/12 * * *", TimeZoneInfo.FindSystemTimeZoneById("India Standard Time"));                 //cron for backing up twice a day
            RecurringJob.AddOrUpdate(() => new RepetitionsManager().updateRepetionsKeeper(), Cron.Hourly, TimeZoneInfo.FindSystemTimeZoneById("India Standard Time")); //cron for updating RepetitionsKeeper every hour
            RecurringJob.AddOrUpdate(() => AutoBackup.cleanDBofTempTable(), "0 5/12 * * *", TimeZoneInfo.FindSystemTimeZoneById("India Standard Time"));               //cron for backing up twice a day

            //Scheduling background backups Ends

            /*
             * Logs may later be changed to logging in a text file
             * Both logs can be maintained
             * text file logging can help back logging even when SQL server is down
             */

            app.UseHangfireDashboard();
            app.UseHangfireServer();
            ////HangFire Configuration Ends



            /*Setting Static manual keys for viewstate validation
             * Setting this to avoid the validation Message Authentication Code failure problem
             * MUST BE REVIEWED FOR SECURITY LATER
             * Machine key in the configuration file is manipulated in the following section
             * Using SHA1 for validation of the key and encryption
             * Generating a 128 bits key manually
             */
            /*
             * System.Diagnostics.Debug.WriteLine("Start Key generation");
             *
             * RNGCryptoServiceProvider KeyGenerator = new RNGCryptoServiceProvider();
             * int KeyLength = 64;
             *
             * byte[] tempKeyStoreBuffer = new byte[KeyLength / 2];//buffer to store key temporarily during building key
             *
             * KeyGenerator.GetBytes(tempKeyStoreBuffer);
             *
             * StringBuilder CustomKey = new StringBuilder(KeyLength);
             *
             * for (int c = 0; c < tempKeyStoreBuffer.Length; c++)
             * CustomKey.Append(string.Format("{0:X2}",tempKeyStoreBuffer[c]));
             * System.Diagnostics.Debug.WriteLine("This generated: -"+CustomKey+"-");
             *
             * System.Diagnostics.Debug.WriteLine("Finish Key generation");
             *
             *
             * System.Diagnostics.Debug.WriteLine("-----Adding key to the configuration file-----");
             * //Adding manually generated Machine Key to the configuration file
             * System.Diagnostics.Debug.WriteLine("Opening config file");
             * Configuration DataCollectionConfig = WebConfigurationManager.OpenWebConfiguration("~");//Empty string refers to the path of the configuration file in the root of the application
             * System.Diagnostics.Debug.WriteLine("Accessing machine key section");
             * MachineKeySection MKsec = (MachineKeySection)DataCollectionConfig.GetSection("system.web/machineKey");
             *
             *
             *
             * System.Diagnostics.Debug.WriteLine("present validation key: -"+MKsec.ValidationKey+"-"+"\nSetting machine key");
             * MKsec.ValidationKey = CustomKey.ToString();//Setting customkey as the machine validation key
             *
             * System.Diagnostics.Debug.WriteLine("present decryption key: -"+MKsec.DecryptionKey+"-"+"\nSetting decryption key");
             * MKsec.DecryptionKey = CustomKey.ToString();//Setting customkey as the machine decryption key
             *
             * System.Diagnostics.Debug.WriteLine("present  validation mode: -" + MKsec.Validation+ "-" + "\nSetting validation mode");
             * MKsec.Validation = MachineKeyValidation.SHA1;//setting validation as SHA1
             *
             * if (!MKsec.SectionInformation.IsLocked)
             * {
             * //  DataCollectionConfig.Save(ConfigurationSaveMode.Modified);//saving changes to configuration file
             * DataCollectionConfig.Save();
             * //  ConfigurationManager.RefreshSection("system.web/machineKey");
             * System.Diagnostics.Debug.WriteLine("Settings updated");
             * System.Diagnostics.Debug.WriteLine("New Machine Valdation: -"+MKsec.Validation+"-");
             * System.Diagnostics.Debug.WriteLine("New Valdation Key: -"+MKsec.ValidationKey+"-");
             * System.Diagnostics.Debug.WriteLine("New Decryption Key: -"+MKsec.DecryptionKey+"-");
             * }
             * else
             * {//section locked
             * System.Diagnostics.Debug.WriteLine("Could not update because section is locked");
             * }
             *
             *
             * //ENDS//Adding manually generated Machine Key to the configuration file
             * System.Diagnostics.Debug.WriteLine("-----Adding key to the configuration file ENDS-----");
             */
        }
Example #52
0
        // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864



        public void ConfigureAuth(IAppBuilder app)
        {
            // Configure the db context, user manager and signin manager to use a single instance per request
            app.CreatePerOwinContext(ApplicationDbContext.Create);
            app.CreatePerOwinContext <ApplicationUserManager>(ApplicationUserManager.Create);
            app.CreatePerOwinContext <ApplicationSignInManager>(ApplicationSignInManager.Create);

            GlobalConfiguration.Configuration
            .UseSqlServerStorage("INCOMETAXConnectionString");
            //RecurringJob.AddOrUpdate(() => JobsMethods.sendDaily(),Cron.Daily);
            RecurringJob.AddOrUpdate(() => JobsMethods.DailyMessagePercentWise(), Cron.Daily);



            //RecurringJob.AddOrUpdate(() => Console.WriteLine("Daily Job"), Cron.Daily);

            app.UseHangfireDashboard();
            app.UseHangfireServer();

            // Enable the application to use a cookie to store information for the signed in user
            // and to use a cookie to temporarily store information about a user logging in with a third party login provider
            // Configure the sign in cookie
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/Home/index"),
                Provider           = new CookieAuthenticationProvider
                {
                    // Enables the application to validate the security stamp when the user logs in.
                    // This is a security feature which is used when you change a password or add an external login to your account.
                    OnValidateIdentity = SecurityStampValidator.OnValidateIdentity <ApplicationUserManager, ApplicationUser>(
                        validateInterval: TimeSpan.FromMinutes(30),
                        regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
                }
            });
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Enables the application to remember the second login verification factor such as phone or email.
            // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
            // This is similar to the RememberMe option when you log in.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

            // Uncomment the following lines to enable logging in with third party login providers
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
            //{
            //    ClientId = "",
            //    ClientSecret = ""
            //});
        }
Example #53
0
        // For more information on configuring authentication, please visit https://go.microsoft.com/fwlink/?LinkId=301883
        public void ConfigureAuth(IAppBuilder app)
        {
            // Configure the db context, user manager and signin manager to use a single instance per request
            app.CreatePerOwinContext(ApplicationDbContext.Create);
            app.CreatePerOwinContext <ApplicationUserManager>(ApplicationUserManager.Create);
            app.CreatePerOwinContext <ApplicationSignInManager>(ApplicationSignInManager.Create);

            // Enable the application to use a cookie to store information for the signed in user
            // and to use a cookie to temporarily store information about a user logging in with a third party login provider
            // Configure the sign in cookie
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/Account/Login"),
                Provider           = new CookieAuthenticationProvider
                {
                    OnValidateIdentity = SecurityStampValidator.OnValidateIdentity <ApplicationUserManager, ApplicationUser>(
                        validateInterval: TimeSpan.FromMinutes(30),
                        regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
                }
            });
            // Use a cookie to temporarily store information about a user logging in with a third party login provider
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Enables the application to remember the second login verification factor such as phone or email.
            // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
            // This is similar to the RememberMe option when you log in.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

            // Uncomment the following lines to enable logging in with third party login providers
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
            //{
            //    ClientId = "",
            //    ClientSecret = ""
            //});



            #region ---- Hangfire Configuration ----

            var options = new SqlServerStorageOptions
            {
                PrepareSchemaIfNecessary = false
            };
            GlobalConfiguration.Configuration.UseSqlServerStorage("DefaultConnection", options);

            app.UseHangfireDashboard("/hangfire", new DashboardOptions
            {
                Authorization = new[] { new MyAuthorizationFilter() }
            });
            app.UseHangfireServer();
            #endregion
        }
Example #54
0
        public void Configuration(IAppBuilder app)
        {
            string connectionString = ConfigurationManager.ConnectionStrings["SqlConnectionString"].ConnectionString;

            app.UseErrorPage();
            app.UseWelcomePage("/welcome");


            GlobalJobFilters.Filters.Add(new AutomaticRetryAttribute {
                Attempts = 1
            });
            GlobalConfiguration.Configuration.UseSqlServerStorage(
                connectionString,
                new SqlServerStorageOptions {
                QueuePollInterval = TimeSpan.FromSeconds(1)
            })
            .UseDashboardMetric(SqlServerStorage.TotalConnections)
            .UseDashboardMetric(DashboardMetrics.ProcessingCount)
            .UseDashboardMetric(DashboardMetrics.SucceededCount)
            .UseDashboardMetric(DashboardMetrics.FailedCount)
            .UseDashboardMetric(new DashboardMetric("内存", "内存", page =>
            {
                var process = Process.GetCurrentProcess();
                long memory = process.WorkingSet64 / 1024;
                return(new Metric($"{memory:N0}KB")
                {
                    Style = memory > 512000 ? MetricStyle.Info : MetricStyle.Default
                });
            }))
            .UseDashboardMetric(new DashboardMetric("内存峰值", "(内存)峰值", page =>
            {
                var process = Process.GetCurrentProcess();
                long memory = process.PeakWorkingSet64 / 1024;
                return(new Metric($"{memory:N0}KB")
                {
                    Style = memory > 512000 ? MetricStyle.Info : MetricStyle.Default
                });
            }))
            ;

            var options = new DashboardOptions
            {
                Authorization = new[] { new MyRestrictiveAuthorizationFilter() },
                AppPath       = ConfigurationManager.AppSettings["AppPath"] ?? ""
            };

            app.UseHangfireDashboard("/Dashboard", options);

            //app.UseHangfireDashboard();
            app.UseHangfireServer();//new BackgroundJobServerOptions { WorkerCount = 1 });

            //RecurringJob.AddOrUpdate(
            //    () => Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} Recurring job completed successfully!"),
            //    Cron.Minutely, TimeZoneInfo.Local);

            BackgroundJob.Enqueue(() => SucessTask("1"));

            //RecurringJob.AddOrUpdate("正确任务1", () => SucessTask("1"), Cron.Minutely, TimeZoneInfo.Local);
            //RecurringJob.AddOrUpdate("正确任务2", () => SucessTask("2"), Cron.Minutely, TimeZoneInfo.Local);
            //RecurringJob.AddOrUpdate("异常任务", () => FailedTask("异常任务,也是开始"), Cron.Minutely, TimeZoneInfo.Local);
            //RecurringJob.AddOrUpdate("等待任务", () => AwaitTask("等待任务,等啊等"), Cron.Minutely, TimeZoneInfo.Local);
        }
Example #55
0
 void Configure(IAppBuilder app)
 {
     app.UseHangfireDashboard();
     app.UseHangfireServer();
 }
Example #56
0
 private static void ConfigureHangfire(IAppBuilder app, IContainer container)
 {
     GlobalConfiguration.Configuration.UseAutofacActivator(container);
     app.UseHangfireDashboard();
     app.UseHangfireServer();
 }
Example #57
0
        // For more information on configuring authentication, please visit https://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            // Configure the db context, user manager and signin manager to use a single instance per request
            app.CreatePerOwinContext(ApplicationDbContext.Create);
            app.CreatePerOwinContext <ApplicationUserManager>(ApplicationUserManager.Create);
            app.CreatePerOwinContext <ApplicationSignInManager>(ApplicationSignInManager.Create);

            // Enable the application to use a cookie to store information for the signed in user
            // and to use a cookie to temporarily store information about a user logging in with a third party login provider
            // Configure the sign in cookie
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/Account/Login"),
                Provider           = new CookieAuthenticationProvider
                {
                    // Enables the application to validate the security stamp when the user logs in.
                    // This is a security feature which is used when you change a password or add an external login to your account.
                    OnValidateIdentity = SecurityStampValidator.OnValidateIdentity <ApplicationUserManager, ApplicationUser>(
                        validateInterval: TimeSpan.FromMinutes(30),
                        regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
                }
            });
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Enables the application to remember the second login verification factor such as phone or email.
            // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
            // This is similar to the RememberMe option when you log in.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

            // Uncomment the following lines to enable logging in with third party login providers
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
            //{
            //    ClientId = "",
            //    ClientSecret = ""
            //});

            //****************** HANGFIRE ****************
            //Register All Hangfire

            Hangfire.GlobalConfiguration.Configuration
            .SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
            .UseSimpleAssemblyNameTypeSerializer()
            .UseRecommendedSerializerSettings()
            .UseSqlServerStorage("DefaultConnection", new SqlServerStorageOptions
            {
                CommandBatchMaxTimeout       = TimeSpan.FromMinutes(5),
                SlidingInvisibilityTimeout   = TimeSpan.FromMinutes(5),
                QueuePollInterval            = TimeSpan.Zero,
                UseRecommendedIsolationLevel = true,
                UsePageLocksOnDequeue        = true,
                DisableGlobalLocks           = true
            });
            //Authe
            app.UseHangfireDashboard("/hangfire", new DashboardOptions()
            {
                Authorization = new[] { new HangFireAuthorizationFilter() }
            });

            //Init Jobs
            TaskForce.InitJobs();
            //Do you need Dashboard
            app.UseHangfireDashboard();
            //Init Server Starts When All Backgroud  Services has been DeclareD
            app.UseHangfireServer();
        }
Example #58
0
 public void Configuration(IAppBuilder app)
 {
     app.UseErrorPage();
     app.UseHangfireServer();
     app.UseHangfireDashboard("");
 }
Example #59
0
 public void Configuration(IAppBuilder app)
 {
     GlobalConfiguration.Configuration.UseSqlServerStorage("MyDailyQuote");
     app.UseHangfireDashboard();
     app.UseHangfireServer();
 }
Example #60
0
        public void Configuration(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );
            //将默认xml返回数据格式改为json
            config.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
            config.Formatters.JsonFormatter.MediaTypeMappings.Add(new QueryStringMapping("datatype", "json", "application/json"));
            app.UseWebApi(config);

            //HangFire配置
            bool isTaskRun = bool.Parse(System.Configuration.ConfigurationManager.AppSettings["IsTaskRun"]);

            if (!isTaskRun)
            {
                return;
            }

            string hangFireType = System.Configuration.ConfigurationManager.AppSettings["HangFireStoreType"];

            if (hangFireType == "SqlServer")
            {
                //SqlServer数据库
                GlobalConfiguration.Configuration
                .UseSqlServerStorage("HangFireCon").UseConsole();
                //.UseRecurringJob(typeof(RecurringJobService)).UseDefaultActivator();


                //GlobalConfiguration.Configuration.UseRecurringJob("recurringjob.json");
            }
            else if (hangFireType == "MySql")
            {
                //MySql数据库
                MySqlStorage mySqlS = new MySqlStorage("HangFireCon", new MySqlStorageOptions
                {
                    TransactionIsolationLevel  = IsolationLevel.ReadCommitted,
                    QueuePollInterval          = TimeSpan.FromSeconds(15),
                    JobExpirationCheckInterval = TimeSpan.FromHours(1),
                    CountersAggregateInterval  = TimeSpan.FromMinutes(5),
                    PrepareSchemaIfNecessary   = true,
                    DashboardJobListLimit      = 50000,
                    TransactionTimeout         = TimeSpan.FromMinutes(1),
                });
                GlobalConfiguration.Configuration
                .UseStorage(mySqlS).UseConsole();   //.UseRecurringJob(typeof(RecurringJobService)).UseDefaultActivator();
                //配置文件
                //x.UseRecurringJob("recurringjob.json");
            }
            else if (hangFireType == "Redis")
            {
                Redis = ConnectionMultiplexer.Connect(System.Configuration.ConfigurationManager.ConnectionStrings["HangFireCon"].ConnectionString);
                GlobalConfiguration.Configuration
                .UseRedisStorage(Redis).UseConsole().
                UseRecurringJob(typeof(RecurringJobService)).UseDefaultActivator();
            }
            app.UseHangfireDashboard("/hangfire", new DashboardOptions
            {
                Authorization = new[] { new HangFireAuthorizationFilter() },
            });

            app.UseHangfireServer(new BackgroundJobServerOptions
            {
                Queues = new[] { "default", "apis", "jobs" }
            });

            //测试
            //BackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-forget"));

            //BackgroundJob.Schedule(() => Console.WriteLine("Delayed"), TimeSpan.FromDays(1));

            //RecurringJob.AddOrUpdate(() => Console.WriteLine("Daily Job"), Cron.Daily);
            //string cron = string.Empty;
            //RecurringJob.AddOrUpdate<IThumbnailInitialize>(string.Format("图层与地图初始化下载"), x => x.ExcuteJob(null), Cron.Daily, TimeZoneInfo.Local);


            BackgroundJob.Enqueue <ThumbnailInitialize>(x => x.ExcuteJob(null));
        }