public Token Refresh(ServerDto serverDto, LoginDto loginDto, Token tokenToRefresh)
{
IAuthenticationService tokenService = null;
if (serverDto.TokenType == TokenType.SAML)
tokenService = new SamlTokenService(_webRequestManager);
else
tokenService = new JwtTokenService(_webRequestManager);
return tokenService.Refresh(serverDto, loginDto, tokenToRefresh);
}
public AuthTokenDto Login(ServerDto serverDto, LoginDto loginDto, string clientId)
{
IAuthenticationService tokenService = null;
if(serverDto.TokenType == TokenType.SAML)
tokenService = new SamlTokenService(_webRequestManager);
else
tokenService = new JwtTokenService(_webRequestManager);
return tokenService.Authenticate(serverDto, loginDto, clientId);
}
public RegisterController(JwtTokenService jTokenService, IServiceProvider sP)
{
jwtTokenService = jTokenService;
serviceProvider = sP;
}
public async Task <IActionResult> GetToken()
{
return(Ok(new { token = $"Bearer {JwtTokenService.GenerateJSONWebToken(5)}" }));
}
public ChatHub(ChatRoomServices chatRoomServices, AppDbContext dbContext, JwtTokenService jwtTokenService)
{
_chatRoomService = chatRoomServices;
_dbContext = dbContext;
_jwtTokenService = jwtTokenService;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = JwtTokenService.GetValidationParameters(Configuration);
});
services.AddAuthorization(options =>
{
options.AddPolicy("create", policy => policy.RequireClaim("permissions", "create"));
options.AddPolicy("update", policy => policy.RequireClaim("permissions", "update"));
options.AddPolicy("delete", policy => policy.RequireClaim("permissions", "delete"));
options.AddPolicy("read", policy => policy.RequireClaim("permissions", "read"));
options.AddPolicy("send", policy => policy.RequireClaim("permissions", "send"));
});
services.AddDbContext <LiteBerryDbContext>(options =>
{
string connectionString = Configuration.GetConnectionString("DefaultConnection");
options.UseSqlServer(connectionString);
});
//We are not using email so do we need this
services.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.User.RequireUniqueEmail = false;
})
.AddEntityFrameworkStores <LiteBerryDbContext>();
services.AddTransient <IUserService, IdentityUserService>();
services.AddTransient <IActivityLog, ActivityLogRepository>();
services.AddTransient <IDesign, DesignRepository>();
services.AddTransient <IUser, UserRepository>();
services.AddSignalR()
.AddAzureSignalR();
services.AddMvc();
services.AddScoped <JwtTokenService>();
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1", new OpenApiInfo()
{
Title = "LiteBerry",
Version = "v1",
});
});
}
public JwtTokenServiceTests()
{
_jwtTokenServiceSUT = new JwtTokenService();
}
public UIProviderResolver(string t, JwtTokenService jTService)
{
jwtTokenService = jTService;
token = t;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <HotelDbContext>(options =>
{
string connectionString = Configuration.GetConnectionString("DefaultConnection");
options.UseSqlServer(connectionString);
});
services.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores <HotelDbContext>();
//This registers the Jwt token service which allows us to pass tokens for users after they sign in.
services.AddScoped <JwtTokenService>();
//This wires the Authentication for the API it tells the system to always use these schemes to authenticate us
services.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{ // this tells the authentication scheme how and where to validate the token and secret
options.TokenValidationParameters = JwtTokenService.GetValidationParameters(Configuration);
});
services.AddAuthorization(options =>
{
options.AddPolicy("create", policy => policy.RequireClaim("permissions", "create"));
options.AddPolicy("update", policy => policy.RequireClaim("permissions", "update"));
options.AddPolicy("delete", policy => policy.RequireClaim("permissions", "delete"));
});
//Registers Dependency Injection services
//Maps Dependency IWhatever(i.e. IRoom) to correct Repository(RoomRepository)
services.AddTransient <IRoom, RoomRepository>();
services.AddTransient <IAmenity, AmenityRepository>();
services.AddTransient <IHotel, HotelRepository>();
services.AddTransient <IHotelRoom, HotelRoomRepository>();
services.AddTransient <IUserService, IdentityUserService>();
// Adds Controllers
services.AddMvc();
services.AddControllers();
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);
//registers swagger service
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1", new OpenApiInfo()
{
Title = "Async Inn",
Version = "v1"
});
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers(options =>
{
options.Filters.Add(new AuthorizeFilter());
});
services.AddRazorPages();
services.AddDbContext <TodoDbContext>(options =>
{
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "My API", Version = "v1"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer",
});
c.OperationFilter <AuthenticationRequirementOperationFilter>();
});
services
.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores <TodoDbContext>();
services.AddTransient <IUserService, IdentityUserService>();
services.AddTransient <JwtTokenService>();
services.AddSingleton <IEmailService, SendGridEmailService>();
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = JwtTokenService.GetValidationParameters(Configuration);
})
;
services.AddAuthorization(options =>
{
options.AddPolicy("create",
policy => policy.RequireClaim("permissions", "create"));
options.AddPolicy("update",
policy => policy.RequireClaim("permissions", "update"));
options.AddPolicy("delete",
policy => policy.RequireClaim("permissions", "delete"));
});
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers(options =>
{
options.Filters.Add(new AuthorizeFilter());
});
services.AddControllers()
// No infinite reference looping here.
.AddNewtonsoftJson(OptionsBuilderConfigurationExtensions =>
{
OptionsBuilderConfigurationExtensions.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
});
services.AddMvc();
services.AddControllers();
// step 3 Register our DbContext
services.AddDbContext <HotelDbContext>(options =>
{
string connectionString = Configuration.GetConnectionString("DefaultConnection");
options.UseSqlServer(connectionString);
});
services
.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores <HotelDbContext>();
services.AddTransient <IUserService, IdentityUserService>();
services.AddScoped <JwtTokenService>();
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = JwtTokenService.GetValidationParameters(Configuration);
});
services.AddAuthorization(options =>
{
options.AddPolicy("create", policy => policy.RequireClaim("permission", "create"));
options.AddPolicy("update", policy => policy.RequireClaim("permission", "update"));
options.AddPolicy("delete", policy => policy.RequireClaim("permission", "delete"));
});
services.AddTransient <IHotelRepo, DatabaseHotelRepo>();
services.AddTransient <IRoomRepo, DatabaseRoomRepo>();
services.AddTransient <IAmenityRepo, DatabaseAmenityRepo>();
services.AddTransient <IHotelRoom, DatabaseHotelRoomRepo>();
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1", new OpenApiInfo {
Title = "Hotel Info", Version = "v1"
});
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
options.OperationFilter <AuthenticationRequrementOperationFilter>();
});
}
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ArtHubDbContext>(options =>
{
string connectionString = Configuration.GetConnectionString("DefaultConnection");
options.UseSqlServer(connectionString);
});
services.AddControllers();
// Add in the requires a unique email for signup
services.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores <ArtHubDbContext>();
// services.AddTransient go below
services.AddTransient <IUserService, IdentityUserService>();
services.AddTransient <ICollectionRepository, DbCollectionRepository>();
services.AddTransient <IArtRepository, DbArtRepository>();
services.AddTransient <IProfileCollectionRepository, DbProfileCollectionRepository>();
services.AddTransient <IProfileRepository, DbProfileRepository>();
services.AddSingleton <IFileService, AzureFileService>();
services.AddTransient <JwtTokenService>();
services.AddAuthorization();
services
.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = JwtTokenService.GetValidationParamters(Configuration);
});
services.AddSwaggerGen(options =>
{
// Make sure get the "using Statement"
options.SwaggerDoc("v1", new OpenApiInfo()
{
Title = "Digital ArtHub",
Version = "v1",
});
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer,"
});
options.OperationFilter <AuthenticationRequirementOperationFilter>();
});
// Hi Nathan
}
public IdentityController(IMediator mediator, JwtTokenService tokenService)
: base(mediator)
{
this.tokenService = tokenService;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient <IJwtTokenService, RedDeer.Extensions.Security.Authentication.Jwt.JwtTokenService>();
services.Configure <KestrelServerOptions>(options =>
{
options.AllowSynchronousIO = true;
});
services.AddRequestResponseLoggingMiddleware();
services.AddResponseCompression();
services.AddOptions();
services.AddMemoryCache();
this.AddRateLimiting(services);
this.AddJwtAuth(services);
services.AddScoped <ISchema>(
s =>
{
var schema = new SurveillanceSchema(new FuncDependencyResolver(s.GetRequiredService));
return(schema);
});
services.AddSingleton <IActiveRulesService, ActiveRulesService>();
services.AddScoped <IDependencyResolver>(s => new FuncDependencyResolver(s.GetRequiredService));
services.AddScoped <IProvideClaimsPrincipal, GraphQlUserContext>();
services.AddScoped <IGraphQlDbContextFactory, GraphQlDbContextFactory>();
services.AddScoped <ITimeZoneService, TimeZoneService>();
services.AddScoped <IMarketRepository, MarketRepository>();
services.AddScoped <IBrokerRepository, BrokerRepository>();
services.AddScoped <IRuleBreachRepository, RuleBreachRepository>();
services.AddScoped <IOrderRepository, OrderRepository>();
services.AddScoped <ISystemProcessOperationRuleRunRepository, SystemProcessOperationRuleRunRepository>();
services
.AddScoped <ISystemProcessOperationUploadFileRepository, SystemProcessOperationUploadFileRepository>();
services
.AddScoped <ISystemProcessOperationDataSynchroniserRepository,
SystemProcessOperationDataSynchroniserRepository>();
services
.AddScoped <ISystemProcessOperationDistributeRuleRepository,
SystemProcessOperationDistributeRuleRepository>();
services.AddScoped <ISystemProcessOperationRepository, SystemProcessOperationRepository>();
services.AddScoped <ISystemProcessRepository, SystemProcessRepository>();
services.AddScoped <IFinancialInstrumentRepository, FinancialInstrumentRepository>();
services.AddTransient <IRefinitivTickPriceHistoryService, RefinitivTickPriceHistoryService>();
services.AddRefinitivServices();
services.AddTransient <IRefinitivTickPriceHistoryApiConfig>((sp) => new RefinitivTickPriceHistoryApiConfig
{
RefinitivTickPriceHistoryApiAddress = this.Configuration["RefinitivTickPriceHistoryApiAddress"],
RefinitivTickPriceHistoryApiJwtBearerTokenSymetricSecurityKey = this.Configuration["RefinitivTickPriceHistoryApiJwtBearerTokenSymetricSecurityKey"],
RefinitivTickPriceHistoryApiPollingSeconds = this.Configuration.GetValue("RefinitivTickPriceHistoryApiPollingSeconds", 60),
RefinitivTickPriceHistoryApiTimeOutDurationSeconds = this.Configuration.GetValue("RefinitivTickPriceHistoryApiTimeOutDurationSeconds", 600)
});
// Test services should be added at end of list so that they can override defaults
if (this._startupConfig.IsTest)
{
this._startupConfig.ConfigureTestServices(services);
}
var jwtTokenService = new JwtTokenService();
services.AddGraphQlAuth(
_ =>
{
_.AddPolicy(
PolicyManifest.AdminPolicy,
p => p.RequireClaim(
jwtTokenService.ClaimType,
new Claim(ScopeType.Surveillance, AccessType.AdminRead).ToString(),
new Claim(ScopeType.Surveillance, AccessType.AdminWrite).ToString()));
_.AddPolicy(
PolicyManifest.AdminReaderPolicy,
p => p.RequireClaim(
jwtTokenService.ClaimType,
new Claim(ScopeType.Surveillance, AccessType.AdminRead).ToString()));
_.AddPolicy(
PolicyManifest.AdminWriterPolicy,
p => p.RequireClaim(
jwtTokenService.ClaimType,
new Claim(ScopeType.Surveillance, AccessType.AdminWrite).ToString()));
_.AddPolicy(
PolicyManifest.UserPolicy,
p => p.RequireClaim(
jwtTokenService.ClaimType,
new Claim(ScopeType.Surveillance, AccessType.Read).ToString(),
new Claim(ScopeType.Surveillance, AccessType.Write).ToString()));
_.AddPolicy(
PolicyManifest.UserReaderPolicy,
p => p.RequireClaim(
jwtTokenService.ClaimType,
new Claim(ScopeType.Surveillance, AccessType.Read).ToString()));
_.AddPolicy(
PolicyManifest.UserWriterPolicy,
p => p.RequireClaim(
jwtTokenService.ClaimType,
new Claim(ScopeType.Surveillance, AccessType.Write).ToString()));
});
services.AddGraphQL(
o =>
{
o.ExposeExceptions = this._environment.IsDevelopment();
o.EnableMetrics = true;
}).AddUserContextBuilder(i => new GraphQlUserContext {
User = i.User
})
.AddGraphTypes(ServiceLifetime.Scoped).AddDataLoader();
}
public AccountController(JwtTokenService tokenService, UserRepository userRepository)
{
_tokenService = tokenService;
_userRepository = userRepository;
}
// This is very similar to what dotenv did for us in NodeJS
public void ConfigureServices(IServiceCollection services)
{
// 3. Register our DbContext with the app
services.AddDbContext <SchoolDbContext>(options =>
{
// Equivalent to DATABASE_URI
string connectionString = Configuration.GetConnectionString("DefaultConnection");
options.UseSqlServer(connectionString);
});
services.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores <SchoolDbContext>();
services.AddScoped <JwtTokenService>();
// This will eventually allow us to "Decorate" (Annotate) our routes
services.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = JwtTokenService.GetValidationParameters(Configuration);
});
services.AddAuthorization(options =>
{
// Add "Name of Policy", and the Lambda returns a definition
options.AddPolicy("create", policy => policy.RequireClaim("permissions", "create"));
options.AddPolicy("update", policy => policy.RequireClaim("permissions", "update"));
options.AddPolicy("delete", policy => policy.RequireClaim("permissions", "delete"));
options.AddPolicy("deposit", policy => policy.RequireClaim("permissions", "deposit"));
});
// Register my Dependency Injection services
// This mapps the Dependency (IStudent) to the correct Service (StudentRepository)
// "Whenever I see IStudent, use StudentRepository
// This makes StudentRepository swappapble with any alternate implementation
services.AddTransient <ICourse, CourseRepository>();
services.AddTransient <IStudent, StudentRepository>();
services.AddTransient <ITechnology, TechnologyRepository>();
services.AddTransient <IUserService, IdentityUserService>();
// Bring in our controllers
services.AddMvc();
services.AddControllers();
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);
services.AddSwaggerGen(options =>
{
// Make sure get the "using Statement"
options.SwaggerDoc("v1", new OpenApiInfo()
{
Title = "School Demo",
Version = "v1",
});
});
}
