/// <summary>Initializes a new instance of the BaseTokenManager class.</summary>
/// <param name="principalProvider">The principal provider.</param>
/// <param name="cryptoProvider">The crypto provider.</param>
/// <param name="tokenFactory">The token factory.</param>
/// <param name="tokenRepository">The token repository.</param>
protected BaseTokenManager(IPrincipalProvider principalProvider, ICryptoProvider cryptoProvider, ITokenFactory tokenFactory, ITokenRepository tokenRepository)
{
this.CryptoProvider = cryptoProvider;
this.PrincipalProvider = principalProvider;
this.TokenFactory = tokenFactory;
this.tokenRepository = tokenRepository;
}
public RemoveProjectWorkItemHandler(IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IWebHookRepository webHookRepository) {
_projectRepository = projectRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_tokenRepository = tokenRepository;
_webHookRepository = webHookRepository;
}
public SimpleTokenStore(ITokenRepository<AccessToken> accessTokenRepository, ITokenRepository<RequestToken> requestTokenRepository)
{
if (accessTokenRepository == null) throw new ArgumentNullException("accessTokenRepository");
if (requestTokenRepository == null) throw new ArgumentNullException("requestTokenRepository");
_accessTokenRepository = accessTokenRepository;
_requestTokenRepository = requestTokenRepository;
}
/// <summary>
/// Public constructor.
/// </summary>
public TokenService(ITokenRepository tokenRepository, IUserService userService)
{
_tokenRepository = tokenRepository;
_userService = userService;
Mapper.CreateMap<Token, TokenEntity>();
Mapper.CreateMap<TokenEntity, Token >();
}
public AuthController(IUserReposytory userRepo, IAppDataReposytory appDataRepo,
ITokenRepository tokenRepo)
{
_userReposytory = userRepo;
_appDataReposytory = appDataRepo;
_tokenRepository = tokenRepo;
}
public OAuthSession(IOAuthConsumerContext consumerContext, ITokenRepository tokenRepository)
{
ConsumerContext = consumerContext;
ConsumerRequestFactory = DefaultConsumerRequestFactory.Instance;
ConsumerRequestRunner = new DefaultConsumerRequestRunner();
_tokenRepository = tokenRepository;
}
public OAuthInterceptor(IOAuthProvider provider, ITokenRepository<AccessToken> repository)
: base(false)
{
if (provider == null) throw new ArgumentNullException("provider");
if (repository == null) throw new ArgumentNullException("repository");
_provider = provider;
_repository = repository;
}
public TokenService(IHashProvider hashProvider, IUnitOfWork unitOfWork)
{
_hashProvider = hashProvider;
_tokenRespository = unitOfWork.GetRepository<ITokenRepository>();
_tokenRespository.OnAdd += (sender, args) => unitOfWork.Commit();
_tokenRespository.OnDelete += (sender, args) => unitOfWork.Commit();
}
public RemoveProjectWorkItemHandler(IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IWebHookRepository webHookRepository, ICacheClient cacheClient, IMessageBus messageBus, ILoggerFactory loggerFactory = null) : base(loggerFactory) {
_projectRepository = projectRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_tokenRepository = tokenRepository;
_webHookRepository = webHookRepository;
_lockProvider = new CacheLockProvider(cacheClient, messageBus);
}
public AuthenticateController(IMapper mapper, IAuthenticationService authenticationService, ITokenRepository tokenRepository, IUserLoginRepository userLoginRepository, IArtistRepository artistRepository)
{
_mapper = mapper;
_authenticationService = authenticationService;
_tokenRepository = tokenRepository;
_userLoginRepository = userLoginRepository;
_artistRepository = artistRepository;
}
public RemoveOrganizationWorkItemHandler(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IUserRepository userRepository, IWebHookRepository webHookRepository) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_tokenRepository = tokenRepository;
_userRepository = userRepository;
_webHookRepository = webHookRepository;
}
public OAuthHandlerBase(CredentialsVerifier auth)
{
Authenticator = auth;
ConsumerStore = new RainyConsumerStore ();
NonceStore = new TestNonceStore ();
// initialize those classes that are not persisted
// TODO request tokens should be persisted in the future
RequestTokens = new SimpleTokenRepository<RequestToken> ();
}
public EventControllerTests(ITestOutputHelper output) : base(output)
{
_organizationRepository = GetService <IOrganizationRepository>();
_projectRepository = GetService <IProjectRepository>();
_tokenRepository = GetService <ITokenRepository>();
_eventRepository = GetService <IEventRepository>();
_eventQueue = GetService <IQueue <EventPost> >();
_eventUserDescriptionQueue = GetService <IQueue <EventUserDescription> >();
CreateOrganizationAndProjectsAsync().GetAwaiter().GetResult();
}
public AuthControllerTests(ITestOutputHelper output) : base(output)
{
Settings.Current.EnableAccountCreation = true;
Settings.Current.EnableActiveDirectoryAuth = false;
_organizationRepository = GetService <IOrganizationRepository>();
_projectRepository = GetService <IProjectRepository>();
_userRepository = GetService <IUserRepository>();
_tokenRepository = GetService <ITokenRepository>();
CreateOrganizationAndProjectsAsync().GetAwaiter().GetResult();
}
public AuthControllerTests(ITestOutputHelper output, AppWebHostFactory factory) : base(output, factory)
{
_authOptions = GetService <IOptions <AuthOptions> >();
_authOptions.Value.EnableAccountCreation = true;
_authOptions.Value.EnableActiveDirectoryAuth = false;
_organizationRepository = GetService <IOrganizationRepository>();
_projectRepository = GetService <IProjectRepository>();
_userRepository = GetService <IUserRepository>();
_tokenRepository = GetService <ITokenRepository>();
}
public ProfileController(IAccessRuleRepository accessRuleRepository,
IUserRepository userRepository,
IUserSkillRepository userSkillRepository,
IUserCertificationRepository userCertificationRepository,
IUserDocumentRepository userDocumentRepository,
IUserHobbyRepository userHobbyRepository,
ILinkedAccountRepository linkedAccountRepository,
IRoleMemberRepository roleMemberRepository,
IAssetRepository assetRepository,
ILeaveEntitlementRepository leaveEntitlementRepository,
IProjectMemberRepository projectMemberRepository,
IUserTechnologyMapRepository userTechnologyMapRepository,
IEmergencyContactRepository emergencyContactRepository,
IEmployeeDependentRepository employeeDependentRepository,
IUserAwardRepository userAwardRepository,
ITokenRepository tokenRepository,
IAwardRepository awardRepository,
ITechnologyRepository technologyRepository,
ISkillRepository skillRepository,
IHobbyRepository hobbyRepository,
ICertificationRepository certificationRepository,
ISystemSnapshotRepository systemSnapshotRepository,
ISettingsService settingsService,
IEmployeeRepository employeeRepository,
IUnitOfWork unitOfWork)
{
_accessRuleRepository = accessRuleRepository;
_userRepository = userRepository;
_userSkillRepository = userSkillRepository;
_userCertificationRepository = userCertificationRepository;
_userDocumentRepository = userDocumentRepository;
_userHobbyRepository = userHobbyRepository;
_roleMemberRepository = roleMemberRepository;
_leaveEntitlementRepository = leaveEntitlementRepository;
_assetRepository = assetRepository;
_projectMemberRepository = projectMemberRepository;
_userTechnologyMapRepository = userTechnologyMapRepository;
_emergencyContactRepository = emergencyContactRepository;
_employeeDependentRepository = employeeDependentRepository;
_tokenRepository = tokenRepository;
_awardRepository = awardRepository;
_systemSnapshotRepository = systemSnapshotRepository;
_userAwardRepository = userAwardRepository;
_technologyRepository = technologyRepository;
_skillRepository = skillRepository;
_hobbyRepository = hobbyRepository;
_certificationRepository = certificationRepository;
_employeeRepository = employeeRepository;
_linkedAccountRepository = linkedAccountRepository;
_settingsService = settingsService;
_unitOfWork = unitOfWork;
}
public AuthController(IOptions <AuthOptions> authOptions, IOrganizationRepository organizationRepository, IUserRepository userRepository, ITokenRepository tokenRepository, ICacheClient cacheClient, IMailer mailer, ILogger <AuthController> logger, IDomainLoginProvider domainLoginProvider)
{
_authOptions = authOptions;
_domainLoginProvider = domainLoginProvider;
_organizationRepository = organizationRepository;
_userRepository = userRepository;
_tokenRepository = tokenRepository;
_cache = new ScopedCacheClient(cacheClient, "Auth");
_mailer = mailer;
_logger = logger;
}
/// <summary>Initializes a new instance of the TokenManager class.</summary>
/// <exception cref="ArgumentNullException">
/// Thrown when one or more required arguments are null.
/// </exception>
/// <param name="logger">The logger.</param>
/// <param name="userManager">Manager for users.</param>
/// <param name="principalProvider">The principal provider.</param>
/// <param name="cryptoProvider">The crypto provider.</param>
/// <param name="tokenFactory">The token factory.</param>
/// <param name="tokenRepository">The token repository.</param>
public TokenManager(ILog logger, IUserManager userManager, IPrincipalProvider principalProvider, ICryptoProvider cryptoProvider, ITokenFactory tokenFactory, ITokenRepository tokenRepository)
: base(principalProvider, cryptoProvider, tokenFactory, tokenRepository)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
this.userManager = userManager;
}
public RemoveOrganizationWorkItemHandler(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IUserRepository userRepository, IWebHookRepository webHookRepository, ICacheClient cacheClient, IMessageBus messageBus, ILoggerFactory loggerFactory = null) : base(loggerFactory)
{
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_tokenRepository = tokenRepository;
_userRepository = userRepository;
_webHookRepository = webHookRepository;
_lockProvider = new CacheLockProvider(cacheClient, messageBus);
}
public void GetTokens_FileExists_GetsTokens()
{
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.OpenRead(Arg.Any <string>()).Returns(this.GetTestTokenStream());
this.sut = new JsonFileTokenRepository(fileSystem);
OAuthAccessTokens result = this.sut.GetTokens();
Assert.NotNull(result);
}
/// <summary>
///
/// </summary>
public CommonController(IOwnerCertificationRecordRepository ownerCertificationRecordRepository,
ISmallDistrictRepository smallDistrictRepository,
IOwnerRepository ownerRepository,
IIndustryRepository industryRepository,
ITokenRepository tokenRepository)
{
_ownerCertificationRecordRepository = ownerCertificationRecordRepository;
_smallDistrictRepository = smallDistrictRepository;
_ownerRepository = ownerRepository;
_industryRepository = industryRepository;
_tokenRepository = tokenRepository;
}
public AuthenticationService(ILogger <AuthenticationService> logger, IUserRepository userRepository, IPasswordService passwordService,
ITokenRepository tokenRepository, ISystemClock systemClock, IPatrolRepository patrolRepository, AppConfiguration configuration)
{
_logger = logger;
_userRepository = userRepository;
_passwordService = passwordService;
_tokenRepository = tokenRepository;
_systemClock = systemClock;
_jwtKey = configuration.JwtKey;
_jwtIssuer = configuration.RootUrl;
_patrolRepository = patrolRepository;
}
public SecurityService(IConfiguration configuration, IUserRepository userRepository, ITokenRepository tokenRepository)
{
_key = configuration["Tokens:Key"];
_issuer = configuration["Tokens:Issuer"];
_audience = configuration["Tokens:Audience"];
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public FeedBackController(IMapper mapper,
ISurveyRepository surveyRepository,
ITokenRepository tokenRepository,
IQuestionOptionRepository questionOptionRepository,
IResponseRepository responseRepository)
{
_mapper = mapper;
_surveyRepository = surveyRepository;
_tokenRepository = tokenRepository;
_questionOptionRepository = questionOptionRepository;
_responseRepository = responseRepository;
}
public UsuarioController(
IUsuarioRepository usuarioRepository,
SignInManager <ApplicationUser> signInManager,
UserManager <ApplicationUser> userManager,
ITokenRepository tokenRepository
)
{
_usuarioRepository = usuarioRepository;
_signInManager = signInManager;
_userManager = userManager;
_tokenRepository = tokenRepository;
}
public void GetTokens_Succeeds()
{
File.Copy($"../../../testdata/{TokenFilename}", TokenFilename, true);
this.sut = new JsonFileTokenRepository(new FileSystem());
OAuthAccessTokens result = this.sut.GetTokens();
Assert.NotNull(result);
File.Delete(TokenFilename);
}
public void Authenticate_NoTokens_ThrowsException()
{
ITokenRepository tokenRepository = Substitute.For <ITokenRepository>();
IHttpClient httpClient = Substitute.For <IHttpClient>();
VstsConfig vstsConfig = GetVstsConfig();
tokenRepository.GetTokens().Returns((OAuthAccessTokens)null);
this.sut = new VstsOAuthAuthenticator(httpClient, tokenRepository, vstsConfig);
Assert.Throws <NoTokensException>(() => this.sut.Authenticate());
}
private Login(ITokenRepository tokenRepository, IUserRepository userRepository, ITokenCreator tokenCreator, string appKey, string userName, string password, string device)
{
_tokenRepository = tokenRepository;
_userRepository = userRepository;
_appKey = appKey;
_userName = userName;
_password = password;
_tokenCreator = tokenCreator;
_device = device;
ValidateInstance();
InvalidUsernameOrPasswordExceptionCreator = () => InvalidUsernameOrPasswordException.Create(_userName, _appKey);
}
public async Task <IActionResult> Holders(
[FromServices] KyubeyContext db,
[FromServices] ITokenRepository _tokenRepository,
string id,
CancellationToken cancellationToken)
{
var token = await db.Tokens
.Include(x => x.Curve)
.SingleOrDefaultAsync(x => x.Id == id &&
x.Status == TokenStatus.Active, cancellationToken);
ViewBag.Otc = await db.Otcs.SingleOrDefaultAsync(x => x.Id == id, cancellationToken);
ViewBag.Bancor = await db.Bancors.SingleOrDefaultAsync(x => x.Id == id, cancellationToken);
if (token == null)
{
return(Prompt(x =>
{
x.Title = SR["Token not found"];
x.Details = SR["The token {0} is not found", id];
x.StatusCode = 404;
}));
}
var tokenInfo = _tokenRepository.GetOne(id);
var cancel = new CancellationTokenSource();
cancel.CancelAfter(5000);
try
{
using (var client = new HttpClient()
{
BaseAddress = new Uri("https://cache.togetthere.cn")
})
using (var resposne = await client.GetAsync($"/token/distributed/{tokenInfo.Basic.Contract.Transfer}/{token.Id}"))
{
var dic = await resposne.Content.ReadAsAsync <IDictionary <string, double> >();
ViewBag.Holders = dic.Select(x => new Holder
{
account = x.Key,
amount = x.Value.ToString("0.0000") + " " + token.Id
})
.Take(20)
.ToList();
}
}
catch (TaskCanceledException)
{
}
return(View(await db.Tokens.SingleAsync(x => x.Id == id && x.Status == TokenStatus.Active, cancellationToken)));
}
public async Task <IActionResult> HistoryOrder([FromServices] ITokenRepository _tokenRepository, string id, string account, bool only = false, CancellationToken token = default)
{
IQueryable <MatchReceipt> matches = DB.MatchReceipts
.Where(x => x.Bidder == account || x.Asker == account);
if (only)
{
matches = matches.Where(x => x.TokenId == id);
}
return(Json(await matches.OrderByDescending(x => x.Time).ToListAsync()));
}
public AuthController(UserManager <AppUser> userManager, SignInManager <AppUser> signInManager,
IJwtFactory jwtFactory, IOptions <JwtIssuerOptions> jwtOptions, ILogger <AuthController> logger,
ITokenRepository tokenRepository, IConfiguration configuration)
{
_userManager = userManager;
_signInManager = signInManager;
_jwtFactory = jwtFactory;
_jwtOptions = jwtOptions.Value;
_logger = logger;
_tokenRepository = tokenRepository;
Configuration = configuration;
}
private GetTokenInfo(ITokenRepository tokenRepository, IUserRepository userRepository, ITokenInfoExtractor tokenInfoExtractor,
string token, string appKey, string device)
{
_device = device;
_token = token;
_appKey = appKey;
_tokenRepository = tokenRepository;
_userRepository = userRepository;
_tokenInfoExtractor = tokenInfoExtractor;
ValidateInstance();
InvalidTokenExceptionCreator = () => InvalidTokenException.Create(_token, _appKey, _device);
}
public void GetTokens_FileDoesntExist_ReturnsNull()
{
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.OpenRead(Arg.Any <string>()).Returns((x) => { throw new FileNotFoundException(); });
this.sut = new JsonFileTokenRepository(fileSystem);
OAuthAccessTokens result = this.sut.GetTokens();
Assert.Null(result);
}
public LoginController(IAppRepository appRepository,
ITokenRepository tokenRepository,
ILogRepository logRepository,
ICacheManager memoryCache,
IConfiguration configuration)
{
this.appRepository = appRepository;
this.tokenRepository = tokenRepository;
this.logRepository = logRepository;
this.cacheManager = memoryCache;
this.configuration = configuration;
}
public AuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
IAuthenticationService authenticationService, ITokenRepository tokenRepositry)
: base(options, logger, encoder, clock)
{
_authenticationService = authenticationService;
_tokenRepository = tokenRepositry;
_systemClock = clock;
}
public UserService(IUserRepository repository, IUnitOfWork unitOfWork, IGateUsageRepository gateUsageRepository, IPasswordHasher passwordHasher, ITokenService tokenService, ITokenRepository tokenRepository, IUserPreferencesRepository userPreferencesRepository, IMapper mapper)
: base(repository, unitOfWork, mapper)
{
_repository = repository;
_unitOfWork = unitOfWork;
_gateUsageRepository = gateUsageRepository;
_passwordHasher = passwordHasher;
_tokenService = tokenService;
_tokenRepository = tokenRepository;
_userPreferencesRepository = userPreferencesRepository;
_mapper = mapper;
}
public SendNotificationCommandHandler(
IFireBaseService fireBaseService,
IAppRepository appRepository, INotificationRepository notificationRepository,
ITokenRepository tokenRepository,
ILogger <SendNotificationCommandHandler> logger)
{
this.fireBaseService = fireBaseService;
this.appRepository = appRepository;
this.notificationRepository = notificationRepository;
this.tokenRepository = tokenRepository;
this.logger = logger;
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
ITokenRepository _tokenReposiroty = context.HttpContext.RequestServices.GetRequiredService <ITokenRepository>();
string? token = context.HttpContext.Request.Query["token"];
if (!_tokenReposiroty.isTokenExist(token))
{
context.Result = new UnauthorizedResult();
return;
}
await next();
}
/// <summary>
///
/// </summary>
public VipOwnerApplicationRecordController(
IVipOwnerApplicationRecordRepository vipOwnerApplicationRecordRepository,
IVipOwnerCertificationAnnexRepository vipOwnerCertificationAnnexRepository,
IVipOwnerCertificationConditionRepository vipOwnerCertificationConditionRepository,
IVipOwnerCertificationRecordRepository vipOwnerCertificationRecordRepository,
ITokenRepository tokenRepository)
{
_vipOwnerCertificationConditionRepository = vipOwnerCertificationConditionRepository;
_vipOwnerApplicationRecordRepository = vipOwnerApplicationRecordRepository;
_vipOwnerCertificationAnnexRepository = vipOwnerCertificationAnnexRepository;
_vipOwnerCertificationRecordRepository = vipOwnerCertificationRecordRepository;
_tokenRepository = tokenRepository;
}
public IdentityService(
UserManager <User> userManager,
RoleManager <IdentityRole> roleManager,
JwtSettings jwtSettings,
TokenValidationParameters tokenValidationParameters,
ITokenRepository tokenRepository)
{
_userManager = userManager;
_roleManager = roleManager;
_jwtSettings = jwtSettings;
_tokenValidationParameters = tokenValidationParameters;
_tokenRepository = tokenRepository;
}
public DataHelper(IOrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IUserRepository userRepository,
IEventRepository eventRepository,
IStackRepository stackRepository,
ITokenRepository tokenRepository) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_tokenRepository = tokenRepository;
}
public SimpleTokenStore(ITokenRepository <AccessToken> accessTokenRepository, ITokenRepository <RequestToken> requestTokenRepository)
{
if (accessTokenRepository == null)
{
throw new ArgumentNullException("accessTokenRepository");
}
if (requestTokenRepository == null)
{
throw new ArgumentNullException("requestTokenRepository");
}
_accessTokenRepository = accessTokenRepository;
_requestTokenRepository = requestTokenRepository;
}
/// <summary>
///
/// </summary>
public StationLetterController(
IStationLetterRepository stationLetterRepository,
IStationLetterAnnexRepository stationLetterAnnexRepository,
IStationLetterBrowseRecordRepository stationLetterBrowseRecordRepository,
IUserRepository userRepository,
ITokenRepository tokenRepository)
{
_stationLetterRepository = stationLetterRepository;
_stationLetterAnnexRepository = stationLetterAnnexRepository;
_stationLetterBrowseRecordRepository = stationLetterBrowseRecordRepository;
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public PatrolController(ILogger <PatrolController> logger, IPatrolRepository patrolRepository,
IPatrolCreationService patrolCreationService, IPatrolService patrolService, IUserRepository userRepository,
IAuthenticationService authenticationService, ITokenRepository tokenRepository, ISystemClock systemClock)
{
_logger = logger;
_patrolRepository = patrolRepository;
_patrolCreationService = patrolCreationService;
_patrolService = patrolService;
_userRepository = userRepository;
_authenticationService = authenticationService;
_tokenRepository = tokenRepository;
_systemClock = systemClock;
}
public MainWindow()
{
InitializeComponent();
this.ProgessBar.Style = ProgressBarStyle.Blocks;
_authAuthenticationSettingsRepository =
DependencyContainer.Container.Resolve<IRepository<AuthenticationSettingsModel>>();
_tokenRepository = DependencyContainer.Container.Resolve<ITokenRepository>();
_syncSettingsRepository = DependencyContainer.Container.Resolve<IRepository<SyncSettingsModel>>();
_bus = DependencyContainer.Container.Resolve<IMessageBus>();
_merger = DependencyContainer.Container.Resolve<ICalendarMerge>();
_calendarRepository = DependencyContainer.Container.Resolve<ICalendarRepository>();
_items = new BindingList<CalendarItemViewModel>();
PrepareDataGridView();
}
static OAuthServicesLocator()
{
var consumerStore = new TestConsumerStore();
var nonceStore = new TestNonceStore();
_accessTokenRepository = new InMemoryTokenRepository<DevDefined.OAuth.Storage.Basic.AccessToken>();
_requestTokenRepository = new InMemoryTokenRepository<DevDefined.OAuth.Storage.Basic.RequestToken>();
var tokenStore = new SimpleTokenStore(_accessTokenRepository, _requestTokenRepository);
_provider = new OAuthProvider(tokenStore,
new SignatureValidationInspector(consumerStore),
new NonceStoreInspector(nonceStore),
new TimestampRangeInspector(new TimeSpan(1, 0, 0)),
new ConsumerValidationInspector(consumerStore));
}
public OAuthHandler(IAuthenticator auth,
ITokenRepository<AccessToken> access_token_repo,
ITokenRepository<RequestToken> request_token_repo,
ITokenStore token_store)
{
this.Authenticator = auth;
this.AccessTokens = access_token_repo;
this.RequestTokens = request_token_repo;
this.TokenStore = token_store;
this.ConsumerStore = new RainyConsumerStore ();
//this.NonceStore = new DummyNonceStore ();
// initialize those classes that are not persisted
// TODO request tokens should be persisted in the future
//RequestTokens = new SimpleTokenRepository<RequestToken> ();
SetupInspectors ();
}
protected void Application_Start(object sender, EventArgs e)
{
_requestTokenRepository = new InMemoryTokenRepository<DevDefined.OAuth.Storage.Basic.RequestToken>();
_accessTokenRepository = new InMemoryTokenRepository<DevDefined.OAuth.Storage.Basic.AccessToken>();
var consumerStore = new JiraConsumerStore();
var nonceStore = new TestNonceStore();
var tokenStore = new SimpleTokenStore(_accessTokenRepository, _requestTokenRepository);
_provider = new OAuthProvider(tokenStore,
new SignatureValidationInspector(consumerStore),
new NonceStoreInspector(nonceStore),
new TimestampRangeInspector(new TimeSpan(1, 0, 0)),
new ConsumerValidationInspector(consumerStore)
/*,new OAuth10AInspector(tokenStore)*/);
}
public DataHelper(IOrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IUserRepository userRepository,
IEventRepository eventRepository,
IStackRepository stackRepository,
ITokenRepository tokenRepository,
IDayStackStatsRepository dayStackStats,
IMonthStackStatsRepository monthStackStats,
IDayProjectStatsRepository dayProjectStats,
IMonthProjectStatsRepository monthProjectStats,
BillingManager billingManager) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_tokenRepository = tokenRepository;
_dayStackStats = dayStackStats;
_monthStackStats = monthStackStats;
_dayProjectStats = dayProjectStats;
_monthProjectStats = monthProjectStats;
_billingManager = billingManager;
}
public XeroApiPublicSession(string userAgent, string consumerKey, string consumerSecret, ITokenRepository tokenRepository)
: base(CreateConsumerContext(userAgent, consumerKey, consumerSecret), tokenRepository)
{
}
public TokenManager(IUserRepository userRepository, ITokenRepository tokenRepository) {
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public AuthMessageHandler(ITokenRepository tokenRepository, IUserRepository userRepository) {
_tokenRepository = tokenRepository;
_userRepository = userRepository;
}
public void SetUp()
{
this.tokenRepository = new MemoryTokenRepository();
}
public UsersRatingController(IUserDataAccess userDataAccess, IUsersRepository userRepository,ITokenRepository tokenRepository)
{
_userDataAccess = userDataAccess;
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public XeroApiPartnerSession(string userAgent, string consumerKey, X509Certificate2 signingCertificate, X509Certificate2 sslCertificate, ITokenRepository tokenRepository)
: base(CreateConsumerContext(userAgent, consumerKey, signingCertificate), tokenRepository)
{
ConsumerRequestFactory = new DefaultConsumerRequestFactory(new SimpleCertificateFactory(sslCertificate));
}
public TokenService(ITokenRepository tokenRepository)
{
Auxilium.Validation.Validate.NotNull(tokenRepository);
_tokenRepository = tokenRepository;
}
public TokenController(IMapper mapper, IArtistRepository artistRepository, ITokenRepository tokenRepository)
{
_mapper = mapper;
_artistRepository = artistRepository;
_tokenRepository = tokenRepository;
}
public SampleDataService(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IUserRepository userRepository, ITokenRepository tokenRepository) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public TokenService(IClientRepository clientRepo, ITokenRepository tokenRepo)
{
ClientRepo = clientRepo;
TokenRepo = tokenRepo;
}
public TokenCheck(ITokenRepository tokenRepo)
{
_tokenRepository = tokenRepo;
}
