feixing/Permission.Web/Startup.cs

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.EntityFrameworkCore;
using Permission.Service.IServices;
using Permission.Service.Services;
using Permission.Entity.DbContext;
using AutoMapper;
using Microsoft.Extensions.Caching.Memory;
using System;
using System.Collections.Generic;
using System.IO;
using Permission.Data.Repositories;
using Permission.Service.DTO;
using Permission.Utils.Cache;
using Permission.Web.Models;
using Permission.Infrastructure.Repositories;
using Permission.Entity.System;
using Permission.Infrastructure.Core;
using Microsoft.Extensions.Logging;
using System.Text;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Options;
using NLog;
using NLog.Extensions.Logging;
using NLog.Web;
using Permission.Data;
using Permission.Entity.Chart;
using Permission.Entity.Disk;
using Permission.Entity.Init;
using Permission.Entity.News;
using Permission.Web.Filters;

namespace Permission.Web
{
    public class Startup
    {
        //AutoMapper
        private MapperConfiguration _mapperConfiguration { get; set; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;

            _mapperConfiguration = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile(new AutoMapperProfileConfiguration());
            });
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // Adds a default in-memory implementation of IDistributedCache
            services.AddDistributedMemoryCache();

            //注意：一定要加 sslmode=none 
            var connection = Configuration.GetConnectionString("MySqlConnection");
            //services.AddDbContextPool<PermissionContext>(options => options.UseMySql(connection)).AddEntityFrameworkMySql();
            services.AddDbContextPool<PermissionContext>(options => options.UseMySql(connection, b => b.MigrationsAssembly("Permission.Web"))).AddEntityFrameworkMySql();

            //var connection = Configuration.GetConnectionString("SqlServerConnection");
            //services.AddDbContextPool<PermissionContext>(options => options.UseSqlServer(connection));

            //AutoMapper
            services.AddSingleton<IMapper>(sp => _mapperConfiguration.CreateMapper());

            //DI
            AddDependencies(services);

            //services.AddMvc();

            services.Configure<Dictionary<string, string>>(Configuration.GetSection("Mime"));

            services.AddMvc(options =>
            {
                options.Filters.Add<HttpGlobalExceptionFilter>(); //全局异常
            }).AddJsonOptions(options =>
            {
                options.SerializerSettings.ContractResolver =
                    new Newtonsoft.Json.Serialization.DefaultContractResolver();
            });

            //配置跨域处理
            services.AddCors(options =>
            {
                options.AddPolicy("any", builder =>
                {
                    builder.AllowAnyOrigin() //允许任何来源的主机访问
                    .AllowAnyMethod()
                    .AllowAnyHeader()
                    .AllowCredentials();//指定处理cookie
                });
            });

            services.AddUnitOfWork<PermissionContext>();

            //处理json序列化后字母大小写问题
            //services.AddMvc().AddJsonOptions(op =>
            //{
            //    op.SerializerSettings.ContractResolver =
            //        new Newtonsoft.Json.Serialization.DefaultContractResolver();
            //    op.SerializerSettings.DateFormatString = "yyyy-MM-dd";
            //    //忽略循环引用
            //    //op.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            //});

            services.AddMemoryCache();

            //Session 过期时长分钟
            var sessionOutTime = Configuration.GetValue<int>("WebConfig:SessionTimeOut", 60);

            //cookie
            services.AddAuthentication("QJAuthorizeCookie")
                .AddCookie("QJAuthorizeCookie", options =>
                {
                    options.AccessDeniedPath = ""; //当用户尝试访问资源但没有通过任何授权策略时，这是请求会重定向的相对路径资源。
                    options.LoginPath = "/Account/Login"; //当用户尝试访问资源但尚未认证时，这是请求重定向的相对路径。
                });

            //Use MemoryCache
            services.AddSingleton<IMemoryCache>(factory =>
            {
                var cache = new MemoryCache(new MemoryCacheOptions());
                return cache;
            });

            services.AddSingleton<ICacheService, MemoryCacheService>();

            //Session服务
            services.AddSession(options =>
            {
                // Set a short timeout for easy testing.
                options.IdleTimeout = TimeSpan.FromMinutes(sessionOutTime);
                //options.CookieHttpOnly = true;
            });

            services.Configure<IISOptions>(options =>
            {

            });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, PermissionContext context, IOptions<Dictionary<string, string>> option)
        {
            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);//这是为了防止中文乱码
            loggerFactory.AddNLog();//添加NLog
            app.AddNLogWeb();
            env.ConfigureNLog("nlog.config");//读取Nlog配置文件
            LogManager.Configuration.Variables["connectionString"] = Configuration.GetConnectionString("MySqlConnection");

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseBrowserLink();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            //app.UseDirectoryBrowser(new DirectoryBrowserOptions()
            //{
            //    FileProvider = new PhysicalFileProvider(
            //        Path.Combine(Directory.GetCurrentDirectory(), @"source")),
            //    RequestPath = new PathString("/source/files")
            //});

            app.UseFileServer(new FileServerOptions()
            {
                FileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), @"source")),
                RequestPath = new PathString("/source"),
                EnableDirectoryBrowsing = true
            });

            app.UseDefaultFiles();


            //app.UseStaticFiles();
            var provider = new FileExtensionContentTypeProvider();
            foreach (string key in option.Value.Keys)
            {
                provider.Mappings.Add(key, option.Value[key]);
            }
            app.UseStaticFiles(new StaticFileOptions() { ContentTypeProvider = provider });


            //use cookie
            app.UseAuthentication();

            app.UseSession();

            app.UseCors("any");

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "area",
                    template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");

                routes.MapRoute(
                    name: "default",
                    template: "{controller=Account}/{action=Login}/{id?}");
            });


            //数据库初始化
            DataInitializer.Init(context);
        }

        private IServiceCollection AddDependencies(IServiceCollection services)
        {
            //Repositories
            //services.AddSingleton(typeof(IRepository<SysUser>), typeof(Repository<SysUser>));
            //services.AddSingleton(typeof(IRepository<SysRole>), typeof(Repository<SysRole>));
            //services.AddSingleton(typeof(IRepository<SysMenu>), typeof(Repository<SysMenu>));
            //services.AddSingleton(typeof(IRepository<SysOrganize>), typeof(Repository<SysOrganize>));
            //services.AddScoped<PermissionContext>();

            services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();

            //demo
            //services.AddSingleton<IRepository<DiskFolder>, Repository<DiskFolder>>();
            //services.AddSingleton<IRepository<DiskFile>, Repository<DiskFile>>();

            services.AddSingleton<IBaseRepository<SysUser>, BaseRepository<SysUser>>();
            services.AddSingleton<IBaseRepository<SysRole>, BaseRepository<SysRole>>();
            services.AddSingleton<IBaseRepository<SysMenu>, BaseRepository<SysMenu>>();
            services.AddSingleton<IBaseRepository<SysOrganize>, BaseRepository<SysOrganize>>();
            services.AddSingleton<IBaseRepository<SysDict>, BaseRepository<SysDict>>();
            services.AddSingleton<IBaseRepository<SysDictDetail>, BaseRepository<SysDictDetail>>();
            services.AddSingleton<IBaseRepository<ChartGroup>, BaseRepository<ChartGroup>>();
            services.AddSingleton<IBaseRepository<ChartGroupMessage>, BaseRepository<ChartGroupMessage>>();
            services.AddSingleton<IBaseRepository<ChartPersonMessage>, BaseRepository<ChartPersonMessage>>();
            services.AddSingleton<IBaseRepository<SystemType>, BaseRepository<SystemType>>();
            services.AddSingleton<IBaseRepository<SystemInfo>, BaseRepository<SystemInfo>>();
            services.AddSingleton<IBaseRepository<NewsType>, BaseRepository<NewsType>>();
            services.AddSingleton<IBaseRepository<NewsInfo>, BaseRepository<NewsInfo>>();
            services.AddSingleton<IBaseRepository<NewsFile>, BaseRepository<NewsFile>>();
            services.AddSingleton<IBaseRepository<SysLog>, BaseRepository<SysLog>>();
            services.AddSingleton<IBaseRepository<DiskFolder>, BaseRepository<DiskFolder>>();
            services.AddSingleton<IBaseRepository<DiskFile>, BaseRepository<DiskFile>>();

            //Services
            services.AddScoped<ISysUserService, SysUserService>();
            services.AddScoped<ISysMenuService, SysMenuService>();
            services.AddScoped<ISysRoleService, SysRoleService>();
            services.AddScoped<ISysOrganizeService, SysOrganizeService>();
            services.AddScoped<ISysDictService, SysDictService>();
            services.AddScoped<ISysDictDetailService, SysDictDetailService>();
            services.AddScoped<IChartGroupService, ChartGroupService>();
            services.AddScoped<INewsTypeService, NewsTypeService>();
            services.AddScoped<INewsInfoService, NewsInfoService>();
            services.AddScoped<ISystemTypeService, SystemTypeService>();
            services.AddScoped<ISystemInfoService, SystemInfoService>();
            services.AddScoped<ISysLogService, SysLogService>();
            services.AddScoped<IDiskFolderService, DiskFolderService>();
            services.AddScoped<IDiskFileService, DiskFileService>();

            services.AddScoped<IUserService, UserService>();
            services.AddScoped<UserService>();
            //services.AddScoped<SysUserService>();
            //services.AddScoped<SysRoleService>();
            //services.AddScoped<SysOrganizeService>();

            return services;
        }
    }
}