/// <summary>
/// Constructor.
/// </summary>
/// <param name="configurationManager"></param>
/// <param name="authorizationConfig"></param>
public TokenProvider(
IConfigurationManager configurationManager,
AuthorizationConfig authorizationConfig)
{
this.configurationManager = configurationManager;
this.authorizationConfig = authorizationConfig;
}
private void CreateAndLoginUser()
{
if (!IsValid)
{
return;
}
var createResult = OpenAuth.CreateUser(ProviderName, ProviderUserId, ProviderUserName, userName.Text);
if (!createResult.IsSuccessful)
{
ModelState.AddModelError("UserName", createResult.ErrorMessage);
}
else
{
// User created & associated OK
if (OpenAuth.Login(ProviderName, ProviderUserId, createPersistentCookie: false))
{
//Roles cookie
HttpCookie cookie = new HttpCookie("Paper.Roles", AuthorizationConfig.GetRoles(User.Identity.Name));
Page.Response.Cookies.Add(cookie);
RedirectToReturnUrl();
}
}
}
public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
{
try
{
var actionAuthentication = context.ActionContext.ActionDescriptor.GetCustomAttributes <AuthenticationAttribute>();
//验证
if (
(actionAuthentication.Count > 0 && actionAuthentication.Last().Authenticate == true) ||
(actionAuthentication.Count == 0 && AuthenticationConfig.GetAuthenticateNoAttribute() == true)
)
{
var ticket = context.Request.Headers.GetValues(AuthenticationConfig.AuthenticationString).FirstOrDefault();
if (ticket == null)
{
throw new AuthenticationException("can not get ticket !");
}
object obj = MemCache.Get(AuthenticationConfig.TicketKeyPrefix + ticket);
if (obj == null)
{
AuthorizationConfig.RemoveRoles(ticket);
throw new AuthenticationException("Ticket has Expired !");
}
if (AuthenticationConfig.GetRefreshTicket())
{
MemCache.Add(AuthenticationConfig.TicketKeyPrefix + ticket, obj, DateTime.Now.AddSeconds(AuthenticationConfig.GetTicketExpire()));
}
}
}
catch (Exception ex)
{
throw ex;
}
}
void OnAuthorizeRequest(object sender, EventArgs args)
{
HttpApplication app = (HttpApplication)sender;
HttpContext context = app.Context;
if (context == null || context.SkipAuthorization)
{
return;
}
HttpRequest req = context.Request;
#if NET_2_0
AuthorizationSection config = (AuthorizationSection)WebConfigurationManager.GetSection("system.web/authorization", req.Path, context);
#else
AuthorizationConfig config = (AuthorizationConfig)context.GetConfig("system.web/authorization");
if (config == null)
{
return;
}
#endif
if (!config.IsValidUser(context.User, req.HttpMethod))
{
HttpException e = new HttpException(401, "Unauthorized");
HttpResponse response = context.Response;
response.StatusCode = 401;
response.Write(e.GetHtmlErrorMessage());
app.CompleteRequest();
}
}
public static IServiceCollection ConfigureSecurity(this IServiceCollection services,
IConfiguration configuration)
{
var authorizationConfig = new AuthorizationConfig();
configuration.Bind(nameof(AuthorizationConfig).Replace("Config", null), authorizationConfig);
if (string.IsNullOrEmpty(authorizationConfig.SecretKey))
{
throw new ArgumentNullException("Jwt secret key is empty.");
}
services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters()
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(authorizationConfig.SecretKey)),
ValidateAudience = false,
ValidateLifetime = true,
ValidIssuer = authorizationConfig.Issuer
};
});
return(services);
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Module Enter: Get the authorization configuration section
// and see if this user is allowed or not
void OnEnter(Object source, EventArgs eventArgs)
{
HttpApplication app;
HttpContext context;
app = (HttpApplication)source;
context = app.Context;
if (context.SkipAuthorization)
{
if (context.User.Identity.IsAuthenticated == false)
{
PerfCounters.IncrementCounter(AppPerfCounter.ANONYMOUS_REQUESTS);
}
return;
}
// Get the authorization config object
AuthorizationConfig settings = (AuthorizationConfig)context.GetConfig("system.web/authorization");
// Check if the user is allowed, or the request is for the login page
if (!settings.IsUserAllowed(context.User, context.Request.RequestType))
{
// Deny access
context.Response.StatusCode = 401;
WriteErrorMessage(context);
app.CompleteRequest();
}
else
{
if (context.User.Identity.IsAuthenticated == false)
{
PerfCounters.IncrementCounter(AppPerfCounter.ANONYMOUS_REQUESTS);
}
}
}
public void Configure(object config)
{
if (config is AuthorizationConfig authConfig)
{
_authConfig = authConfig;
}
}
protected void LoggedIn(object sender, EventArgs e)
{
if (Page.Request.IsAuthenticated)
{
HttpCookie cookie = new HttpCookie("Paper.Roles", AuthorizationConfig.GetRoles(Context.User.Identity.Name));
Page.Response.Cookies.Add(cookie);
}
}
public Config()
{
Port = "";
Auth = new AuthorizationConfig();
BotConfig = new BotConfig();
CoinConfig = new CoinSystemConfig();
MiniChatConfig = new MiniChatConfig();
PlayerConfig = new PlayerConfig();
}
public RestrictedDemoAttribute(IOptionsSnapshot <AuthorizationConfig> configOptions)
{
if (configOptions == null)
{
throw new ArgumentNullException(nameof(configOptions));
}
_authorizationConfig = configOptions.Value;
}
public bool Authorize(string table, string action, string roles)
{
List <Guid> _roles = new List <Guid>();
foreach (string rol in roles.Split('|'))
{
_roles.Add(new Guid(rol));
}
return(AuthorizationConfig.Authorize(table, action, _roles));
}
private bool IsAllowAnonymousRequest(ActionExecutingContext context)
{
var controlName = context.Controller.GetType().Name;
var actionName = context.ActionDescriptor.DisplayName.Split("(")[0].Trim();
actionName = actionName.Substring(actionName.LastIndexOf('.') + 1);
var configCenterSetting = AuthorizationConfig.GetIsAllowAnonymousRequest(controlName, actionName);
return(context.Controller.GetType().CustomAttributes.Any(m => m.AttributeType.Name == typeof(AllowAnonymousAttribute).Name) ||
configCenterSetting);
}
protected virtual void Awake()
{
_authMethodConfig = this.GetComponent <AuthorizationConfig>();
if (!_authMethodConfig)
{
Debug.LogError("No authorization config found on Spotify Service! Is the selected authorization method's config next to the service?");
return;
}
StartService();
}
private void SetupControllerMap(List <Type> controllers)
{
var service = _container.Resolve <IControllerMapService>();
var map = new AuthorizationConfig
{
Map = service.BuildControllerMap(controllers)
};
_container.Register(Component.For <AuthorizationConfig>().Instance(map).LifestyleSingleton());
}
/// <summary>
/// Initializes the insatnce of the class
/// </summary>
/// <param name="httpClientFactory">The HTTP client factory.</param>
/// <param name="servicesConfig">The services configuration.</param>
/// <param name="logger">Represents the logger</param>
/// <param name="authorizationConfig">The authorization configuration.</param>
public UserIdExistsRequirementHandler(
IHttpClientFactory httpClientFactory,
ServicesConfig servicesConfig,
ILogger <UserIdExistsRequirementHandler> logger,
AuthorizationConfig authorizationConfig)
{
this.httpClientFactory = httpClientFactory;
this.servicesConfig = servicesConfig;
this.logger = logger;
this.authorizationConfig = authorizationConfig;
}
public static void RegisterUserAndRole(object user, List <string> roles)
{
string ticket = Tools.ToShortMD5(Guid.NewGuid().ToString("N"));
DateTime expired = DateTime.Now.AddSeconds(AuthenticationConfig.GetTicketExpire());
HttpContext.Current.Response.Headers.Add(AuthenticationConfig.AuthenticationString, ticket);
if (user != null)
{
MemCache.Add(AuthenticationConfig.TicketKeyPrefix + ticket, user, expired);
}
if (roles != null && roles.Count > 0)
{
AuthorizationConfig.AddRoles(ticket, roles);
}
}
static internal bool RequestRequiresAuthorization(HttpContext context)
{
if (context.SkipAuthorization)
{
return(false);
}
AuthorizationConfig settings = (AuthorizationConfig)context.GetConfig("system.web/authorization");
// Check if the anonymous user is allowed
if (_AnonUser == null)
{
_AnonUser = new GenericPrincipal(new GenericIdentity(String.Empty, String.Empty), new String[0]);
}
return(settings.IsUserAllowed(_AnonUser, context.Request.RequestType));
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
AuthorizationConfig.RegisterOAuth(app);
WebApiConfig.RegisterRoutes(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
WebAppConfig.RegisterRoutes(RouteTable.Routes);
UnityConfig.RegisterComponents(config);
SwaggerConfig.Register(config);
AutoMapper.Mapper.Initialize(cfg => cfg.AddProfile <AutoMapperConfig>());
Database.SetInitializer(new MigrateDatabaseToLatestVersion <FavBooksContext, FavBooks.DataAccess.Migrations.Configuration>());
}
private void DebugDataConfig()
{
BotConfig = new BotConfig()
{
IsDualMode = false,
BotName = "Valerabot",
StreamName = "imshadowmafia",
BotColor = new BotColor()
{
RbgColor = new System.Windows.Media.SolidColorBrush(Color.FromRgb(255, 0, 0)), Color = ChatColorPresets.Red
}
};
Auth = new AuthorizationConfig()
{
BotAuth = new AuthorizationInstance()
{
Tokens = new TwitchAuthResponse()
{
AccessToken = "51o0g399yiaqsab1vde59kpba4f685"
}
},
StreamerAuth = new AuthorizationInstance()
{
Tokens = new TwitchAuthResponse()
{
AccessToken = "51o0g399yiaqsab1vde59kpba4f685"
}
}
};
CoinConfig = new CoinSystemConfig()
{
StreamOfflineAccrualInterval = 1,
StreamOnlineAccrualInterval = 2,
IsEnabled = true,
CoinsName = "ShadowCoins",
CoinSystemCustomMode = false,
Unfollow = 10,
Follower = 15,
Subscriber = 20,
};
}
public SignInManager(IOptionsSnapshot <AuthorizationConfig> configOptions,
IHttpContextAccessor contextAccessor,
IAuthenticationSchemeProvider schemes)
{
if (configOptions == null)
{
throw new ArgumentNullException(nameof(configOptions));
}
if (contextAccessor == null)
{
throw new ArgumentNullException(nameof(contextAccessor));
}
if (schemes == null)
{
throw new ArgumentNullException(nameof(schemes));
}
_authorizationConfig = configOptions.Value;
_contextAccessor = contextAccessor;
_schemes = schemes;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddMemoryCache();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddAuthorization(options => { options.DefaultPolicy = new AuthorizationPolicyBuilder(JwtBearerDefaults.AuthenticationScheme).RequireAuthenticatedUser().Build(); });
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options => { options.RequireHttpsMetadata = false; options.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuer = true, ValidIssuer = AuthorizationConfig.server, ValidateAudience = true, ValidAudience = AuthorizationConfig.issuer, ValidateLifetime = true, IssuerSigningKey = AuthorizationConfig.SymmetricSecurityKey(), ValidateIssuerSigningKey = true
}; });
services.AddDbContext <UsersIEP_dev01Context>(options => options.UseSqlServer(Configuration.GetConnectionString("ConnectionStrings")));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="tokenProvider"></param>
/// <param name="authorizationConfig"></param>
public TokenService(ITokenProvider tokenProvider,
AuthorizationConfig authorizationConfig)
{
this.authorizationConfig = authorizationConfig;
this.tokenProvider = tokenProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthController"/> class.
/// </summary>
/// <param name="authConfigOptions">The authentication configuration options.</param>
protected AuthApiController(IOptions <AuthorizationConfig> authConfigOptions)
{
this._authConfig = authConfigOptions.Value;
bearerAuthKeys = this._authConfig.BearerAuthKeys;
}
public JwtService(IConfiguration configuration)
{
_config = new AuthorizationConfig();
configuration.Bind(nameof(AuthorizationConfig).Replace("Config", null), _config);
}
/// <summary>
/// Set all application config to default
/// </summary>
/// <param name="debugMode">if true then debug mode</param>
public void DefaultConfig(bool debugMode = true)
{
//personal data
if (debugMode)
{
DebugDataConfig();
}
else
{
BotConfig = new BotConfig()
{
IsDualMode = false,
BotName = "YouBotName",
StreamName = "YouStreamName",
BotColor = new BotColor()
{
RbgColor = new System.Windows.Media.SolidColorBrush(Color.FromRgb(255, 0, 0)), Color = ChatColorPresets.Red
}
};
Auth = new AuthorizationConfig()
{
BotAuth = new AuthorizationInstance()
{
Tokens = new TwitchAuthResponse()
{
AccessToken = "You need get oauth token"
}
},
StreamerAuth = new AuthorizationInstance()
{
Tokens = new TwitchAuthResponse()
{
AccessToken = "You need get oauth token"
}
}
};
CoinConfig = new CoinSystemConfig()
{
StreamOfflineAccrualInterval = 1,
StreamOnlineAccrualInterval = 1,
IsEnabled = true,
CoinsName = "Coins",
CoinSystemCustomMode = false,
Unfollow = 5,
Follower = 10,
Subscriber = 20,
};
}
Port = "8080";
MiniChatConfig.ChatUsage = true;
MiniChatConfig.Topmost = true;
MiniChatConfig.IsLocked = false;
MiniChatConfig.ChatSettingsAndInput = true;
MiniChatConfig.ChatPosition = new Point(100, 200);
MiniChatConfig.ChatSize = new Size(400, 300);
MiniChatConfig.BgColor = Color.FromArgb(255, 239, 238, 241);
PlayerConfig.Autoplay = true;
PlayerConfig.ChatPlaylistOn = true;
PlayerConfig.IsUsingCoinSystem = true;
PlayerConfig.CurrentSongNotify = true;
PlayerConfig.SongPrice = 10;
PlayerConfig.SkipSongPrice = 30;
PlayerConfig.FirstSongPrice = 50;
PlayerConfig.UnfollowRequestsPerHours = 3;
PlayerConfig.FollowerRequestsPerHours = 6;
PlayerConfig.SubscriberRequestsPerHours = 10;
PlayerConfig.MinRequestRang = TwitchRangs.Unfollower;
}
private void ProcessProviderResult()
{
// Process the result from an auth provider in the request
ProviderName = OpenAuth.GetProviderNameFromCurrentRequest();
if (String.IsNullOrEmpty(ProviderName))
{
Response.Redirect(FormsAuthentication.LoginUrl);
}
// Build the redirect url for OpenAuth verification
var redirectUrl = "~/Account/RegisterExternalLogin.aspx";
var returnUrl = Request.QueryString["ReturnUrl"];
if (!String.IsNullOrEmpty(returnUrl))
{
redirectUrl += "?ReturnUrl=" + HttpUtility.UrlEncode(returnUrl);
}
// Verify the OpenAuth payload
var authResult = OpenAuth.VerifyAuthentication(redirectUrl);
ProviderDisplayName = OpenAuth.GetProviderDisplayName(ProviderName);
if (!authResult.IsSuccessful)
{
Title = "External login failed";
userNameForm.Visible = false;
ModelState.AddModelError("Provider", String.Format("External login {0} failed.", ProviderDisplayName));
// To view this error, enable page tracing in web.config (<system.web><trace enabled="true"/></system.web>) and visit ~/Trace.axd
Trace.Warn("OpenAuth", String.Format("There was an error verifying authentication with {0})", ProviderDisplayName), authResult.Error);
return;
}
// User has logged in with provider successfully
// Check if user is already registered locally
if (OpenAuth.Login(authResult.Provider, authResult.ProviderUserId, createPersistentCookie: false))
{
//Roles cookie
HttpCookie cookie = new HttpCookie("Paper.Roles", AuthorizationConfig.GetRoles(authResult.UserName));
Page.Response.Cookies.Add(cookie);
RedirectToReturnUrl();
}
// Store the provider details in ViewState
ProviderName = authResult.Provider;
ProviderUserId = authResult.ProviderUserId;
ProviderUserName = authResult.UserName;
// Strip the query string from action
Form.Action = ResolveUrl(redirectUrl);
if (User.Identity.IsAuthenticated)
{
//Roles cookie
HttpCookie cookie = new HttpCookie("Paper.Roles", AuthorizationConfig.GetRoles(User.Identity.Name));
Page.Response.Cookies.Add(cookie);
// User is already authenticated, add the external login and redirect to return url
OpenAuth.AddAccountToExistingUser(ProviderName, ProviderUserId, ProviderUserName, User.Identity.Name);
RedirectToReturnUrl();
}
else
{
// User is new, ask for their desired membership name
userName.Text = authResult.UserName;
}
}
public void GetEdgeHubConfig_ValidInput_MappingIsCorrect()
{
var validator = new Mock <BrokerPropertiesValidator>();
validator
.Setup(v => v.ValidateAuthorizationConfig(It.IsAny <AuthorizationProperties>()))
.Returns(new List <string>());
var routeFactory = new EdgeRouteFactory(new Mock <IEndpointFactory>().Object);
var configParser = new EdgeHubConfigParser(routeFactory, validator.Object);
EdgeHubDesiredProperties properties = ConfigTestData.GetTestData();
// act
EdgeHubConfig result = configParser.GetEdgeHubConfig(properties);
// assert
validator.Verify(v => v.ValidateAuthorizationConfig(properties.BrokerConfiguration.Authorizations), Times.Once());
Assert.Equal("1.2.0", result.SchemaVersion);
AuthorizationConfig authzConfig = result
.BrokerConfiguration
.Expect(() => new InvalidOperationException("missing broker config"))
.Authorizations
.Expect(() => new InvalidOperationException("missing authorization config"));
Assert.Equal(3, authzConfig.Statements.Count);
var result0 = authzConfig.Statements[0];
Assert.Equal(Effect.Deny, result0.Effect);
Assert.Equal(2, result0.Identities.Count);
Assert.Equal("device_1", result0.Identities[0]);
Assert.Equal("device_3", result0.Identities[1]);
Assert.Equal(1, result0.Operations.Count);
Assert.Equal("mqtt:publish", result0.Operations[0]);
Assert.Equal(2, result0.Resources.Count);
Assert.Equal("system/alerts/+", result0.Resources[0]);
Assert.Equal("core/#", result0.Resources[1]);
var result1 = authzConfig.Statements[1];
Assert.Equal(Effect.Allow, result1.Effect);
Assert.Equal(2, result1.Identities.Count);
Assert.Equal("device_1", result1.Identities[0]);
Assert.Equal("device_3", result1.Identities[1]);
Assert.Equal(2, result1.Operations.Count);
Assert.Equal("mqtt:publish", result1.Operations[0]);
Assert.Equal("mqtt:subscribe", result1.Operations[1]);
Assert.Equal(2, result1.Resources.Count);
Assert.Equal("topic/a", result1.Resources[0]);
Assert.Equal("topic/b", result1.Resources[1]);
var result2 = authzConfig.Statements[2];
Assert.Equal(Effect.Allow, result2.Effect);
Assert.Equal(1, result2.Identities.Count);
Assert.Equal("device_2", result2.Identities[0]);
Assert.Equal(2, result2.Operations.Count);
Assert.Equal("mqtt:publish", result2.Operations[0]);
Assert.Equal("mqtt:subscribe", result2.Operations[1]);
Assert.Equal(2, result2.Resources.Count);
Assert.Equal("topic1", result2.Resources[0]);
Assert.Equal("topic2", result2.Resources[1]);
}
string GenerateToken(string username, double lifetime)
{
Claim[] claims = new Claim[] { new Claim(ClaimsIdentity.DefaultNameClaimType, username) };
ClaimsIdentity claimsIdentity = new ClaimsIdentity(claims, "Token", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
JwtSecurityToken jwtSecurityToken = new JwtSecurityToken(issuer: AuthorizationConfig.server, audience: AuthorizationConfig.issuer, notBefore: DateTime.UtcNow, claims: claimsIdentity.Claims, expires: DateTime.UtcNow.Add(TimeSpan.FromMinutes(lifetime)), signingCredentials: new SigningCredentials(AuthorizationConfig.SymmetricSecurityKey(), SecurityAlgorithms.HmacSha256));
return(new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(x => x.EnableEndpointRouting = false);
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
var appInsightsConfig = new AppInsightsConfig
{
InstrumentationKey = Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"]
};
services.AddSingleton(appInsightsConfig);
services.AddApplicationInsightsTelemetry(appInsightsConfig.InstrumentationKey);
var apiConfig = new ApiConfig
{
BaseUrl = Configuration["ApiUrl"],
MrcApiUrl = Configuration["MrcApiUrl"],
DocEntitiesApiUrl = Configuration["DocEntitiesApiUrl"],
WidgetApiUrl = Configuration["WidgetApiUrl"]
};
services.AddSingleton(apiConfig);
var orgConfig = new OrganizationConfig
{
Logo = Configuration["OrganizationLogo"],
Name = Configuration["OrganizationName"],
Url = Configuration["OrganizationWebSiteUrl"],
};
services.AddSingleton(orgConfig);
var authorizationConfig = new AuthorizationConfig
{
AuthorityUri = Configuration["AuthorityUri"],
ResourceUrl = Configuration["ResourceUrl"],
RedirectUrl = Configuration["RedirectUrl"],
PowerBIApiUrl = Configuration["PowerBIApiUrl"],
ApplicationId = Configuration["ApplicationId"],
LoggingRequestUrl = Configuration["LoggingRequestUrl"]
};
#if DEBUG
authorizationConfig.RedirectUrl = Configuration["RedirectUrlLocalhost"];
#endif
services.AddSingleton(authorizationConfig);
var appConfig = new AppConfig
{
ApiConfig = apiConfig,
AppInsights = appInsightsConfig,
Organization = orgConfig,
Authorization = authorizationConfig,
Customizable = Configuration["Customizable"].Equals("true", StringComparison.InvariantCultureIgnoreCase)
};
services.AddSingleton(appConfig);
services.AddSingleton <IFileProvider>(new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot")));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
public void ConfigureServices(IServiceCollection services)
{
// IoC para autoMapper
services.AddAutoMapper();
// Obtendo parametros AuthorizationConfigs do appsettings.json
services.Configure <AuthorizationConfigs>(Configuration.GetSection("AuthorizationConfigs"));
// Configuração da internacionalização
services.AddJsonLocalization(options => options.ResourcesPath = "Internationalization");
WRIoC.Register(services);
services.AddSingleton <IConfiguration>(Configuration);
services.AddScoped <IUsuarioBase, UsuarioBase>();
services.AddDbContext <WRContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))
.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning)));
// Configurando ServiceLocator
ServiceLocator.Init(services.BuildServiceProvider());
// Configuração AddIdentityServer
services.AddIdentityServer()
.AddSigningCredential(AuthorizationConfig.GetCertificate())
.AddInMemoryApiResources(AuthorizationConfig.GetApiResources())
.AddInMemoryClients(AuthorizationConfig.GetClients())
.AddResourceOwnerValidator <GrantValidator>();
JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
// Configuração Client
services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
.AddIdentityServerAuthentication(options => AuthorizationConfig.GetServerAutentication(options));
CorsAuthorization.SetAllowAll(services);
services.AddCors(options =>
{
options.AddPolicy("ALL", builder => builder
.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials());
});
services.AddMvcCore().AddAuthorization();
var csvFormatterOptions = new CsvFormatterOptions();
services.AddMvc(options =>
{
options.Filters.Add(typeof(DomainExceptionFilter));
options.ModelBinderProviders.Insert(0, new ProviderModelBinder());
options.RespectBrowserAcceptHeader = true;
options.InputFormatters.Add(new CsvInputFormatter(csvFormatterOptions));
options.OutputFormatters.Add(new CsvOutputFormatter(csvFormatterOptions));
options.FormatterMappings.SetMediaTypeMappingForFormat("csv", "text/csv");
})
.AddCsvSerializerFormatters()
.AddViewLocalization()
.AddJsonOptions(x => SetDefaultSerializerSettings(x.SerializerSettings))
.AddApplicationPart(typeof(Startup).Assembly);
}