public bool RevokeToken(string token)
{
try
{
ClaimsPrincipal principal = GetPrincipal(token);
if (principal == null)
{
return(false);
}
ClaimsIdentity identity = (ClaimsIdentity)principal.Identity;
string audience = identity.Claims.First(x => x.Type == "aud").Value;
List <TokenInfo> listToken = new TokenRepository().GetByCriteria <TokenInfo>(new TokenInfo()
{
ClientId = ObjectId.Parse(audience)
});
if (listToken.Count > 0)
{
listToken.FirstOrDefault().TokenStatus = TokenStatus.Terminate;
new TokenRepository().Update <TokenInfo>(listToken.FirstOrDefault());
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <JsonStatusResult> Logout()
{
try
{
var userId = CurUser.Identifier();
if (userId == null)
{
return(StatusMsg(HttpStatusCode.Unauthorized, "unaothorized"));
}
var token = CurUser.FindByType(ExternalClaimTypes.AuthToken);
if (token != null)
{
TokenRepository reps = new TokenRepository();
await reps.RemoveUserTokenAsync(userId.Value, token);
}
return(StatusMsg(HttpStatusCode.OK, "success"));
}
catch (HttpDataException hre)
{
return(StatusMsg(hre.ResponseStatus, hre.Message));
}
catch (Exception ex)
{
_logger.Error(ex);
return(StatusMsg(HttpStatusCode.InternalServerError, ex.Message));
}
}
public ActionResult TokenLogin(TokenViewModel model)
{
// Create repos
TokenRepository tokenRepository = new TokenRepository(db);
UserRepository userRepository = new UserRepository(db);
User user = userRepository.GetUserById(model.UserId);
if (tokenRepository.VerifyToken(model.Token, model.UserId))
{
LogUserAction("Login successful", model.UserId);
SessionHelper.SetUser(user);
if (SessionHelper.HasClaim(Claims.Admin))
{
return(RedirectToAction("Index", "Admin"));
}
else if (SessionHelper.HasClaim(Claims.Create))
{
return(RedirectToAction("Index", "User"));
}
return(RedirectToAction("Index", "Home"));
}
LogUserAction("Invalid token", model.UserId);
ViewBag.Status = "invalid_token";
ModelState.AddModelError("Token", "Token is not valid");
return(View("TokenLogin", model));
}
public ActionResult Callback(string code)
{
TokenRepository repository = new TokenRepository(Request, Response);
repository.Callback(code);
return(RedirectToAction("Index"));
}
public ActionResult Connect(string hostUrl)
{
TokenRepository repository = new TokenRepository(Request, Response);
repository.Connect(hostUrl);
return(View());
}
public AccessToken RenewAccessToken(IToken accessToken, string sessionHandle)
{
var requestToken = TokenRepository.GetRequestToken();
if (requestToken == null)
{
throw new ApplicationException("The token repository doesn't have a current request token");
}
AccessToken token = BuildRenewAccessTokenContext(accessToken, sessionHandle)
.Select(collection =>
new AccessToken
{
ConsumerKey = accessToken.ConsumerKey,
Token = ParseResponseParameter(collection, Parameters.OAuth_Token),
TokenSecret = ParseResponseParameter(collection, Parameters.OAuth_Token_Secret),
SessionHandle = ParseResponseParameter(collection, Parameters.OAuth_Session_Handle),
SessionExpiresIn = ParseResponseParameter(collection, Parameters.OAuth_Authorization_Expires_In),
ExpiresIn = ParseResponseParameter(collection, Parameters.OAuth_Expires_In),
CreatedDateUtc = DateTime.UtcNow
});
AssertValidAccessToken(token);
TokenRepository.SaveAccessToken(token);
return(token);
}
public StoresController(
IServiceProvider serviceProvider,
BTCPayServerOptions btcpayServerOptions,
BTCPayServerEnvironment btcpayEnv,
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
RateFetcher rateFactory,
ExplorerClientProvider explorerProvider,
IFeeProviderFactory feeRateProvider,
LanguageService langService,
IHostingEnvironment env,
InvoiceController invoiceController)
{
_RateFactory = rateFactory;
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_LangService = langService;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_Env = env;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
_FeeRateProvider = feeRateProvider;
_ServiceProvider = serviceProvider;
_BtcpayServerOptions = btcpayServerOptions;
_BTCPayEnv = btcpayEnv;
_InvoiceController = invoiceController;
}
public async Task CreateAsync(AuthenticationTokenCreateContext context)
{
var refreshTokenId = Guid.NewGuid().ToString("n");
TokenRepository reps = new TokenRepository();
var refreshTokenLifeTime = context.OwinContext.Get <string>("as:clientRefreshTokenLifeTime");
var token = new RefreshToken()
{
Id = Helper.GetHash(refreshTokenId),
ClientId = clientid,
Subject = context.Ticket.Identity.Name,
IssuedUtc = DateTime.UtcNow,
ExpiresUtc = DateTime.UtcNow.AddMinutes(Convert.ToDouble(refreshTokenLifeTime))
};
context.Ticket.Properties.IssuedUtc = token.IssuedUtc;
context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc;
token.ProtectedTicket = context.SerializeTicket();
var result = await _repo.AddRefreshToken(token);
if (result)
{
context.SetToken(refreshTokenId);
}
}
public StoresController(
NBXplorerDashboard dashboard,
IServiceProvider serviceProvider,
BTCPayServerOptions btcpayServerOptions,
BTCPayServerEnvironment btcpayEnv,
IOptions <MvcJsonOptions> mvcJsonOptions,
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
BTCPayRateProviderFactory rateFactory,
ExplorerClientProvider explorerProvider,
IFeeProviderFactory feeRateProvider,
LanguageService langService,
IHostingEnvironment env)
{
_RateFactory = rateFactory;
_Dashboard = dashboard;
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_LangService = langService;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_Env = env;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
_MvcJsonOptions = mvcJsonOptions.Value;
_FeeRateProvider = feeRateProvider;
_ServiceProvider = serviceProvider;
_BtcpayServerOptions = btcpayServerOptions;
_BTCPayEnv = btcpayEnv;
}
public StoresController(
IServiceProvider serviceProvider,
IOptions <MvcJsonOptions> mvcJsonOptions,
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
ExplorerClientProvider explorerProvider,
IFeeProviderFactory feeRateProvider,
IHostingEnvironment env)
{
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_Env = env;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
_MvcJsonOptions = mvcJsonOptions.Value;
_FeeRateProvider = feeRateProvider;
_ServiceProvider = serviceProvider;
}
public RequestToken GetRequestToken(Uri callbackUri)
{
IConsumerRequest request = Request()
.ForMethod("GET")
.AlterContext(context => context.CallbackUrl = (callbackUri == null) ? "oob" : callbackUri.ToString())
.AlterContext(context => context.Token = null)
.ForUri(ConsumerContext.RequestTokenUri)
.SignWithoutToken();
var results = request.Select(collection =>
new
{
ConsumerContext.ConsumerKey,
Token = ParseResponseParameter(collection, Parameters.OAuth_Token),
TokenSecret = ParseResponseParameter(collection, Parameters.OAuth_Token_Secret),
CallackConfirmed = WasCallbackConfimed(collection)
});
if (!results.CallackConfirmed && CallbackMustBeConfirmed)
{
throw Error.CallbackWasNotConfirmed();
}
var requestToken = new RequestToken
{
ConsumerKey = results.ConsumerKey,
Token = results.Token,
TokenSecret = results.TokenSecret
};
TokenRepository.SaveRequestToken(requestToken);
return(requestToken);
}
public async Task <IActionResult> Status()
{
Identity currentIdentity = await GetIdentity();
if (!currentIdentity.IsSiteAdmin())
{
return(Unauthorized());
}
List <string> currentLogins = new();
foreach (var login in _identityManager.GetCurrentIdentities())
{
if (login is DiscordOAuthIdentity)
{
try
{
var user = login.GetCurrentUser();
if (user == null)
{
currentLogins.Add($"Invalid user.");
}
else
{
currentLogins.Add($"{user.Username}#{user.Discriminator}");
}
}
catch (Exception e)
{
_logger.LogError(e, "Error getting logged in user.");
currentLogins.Add($"Invalid user.");
}
}
}
StatusRepository repo = StatusRepository.CreateDefault(_serviceProvider);
StatusDetail botDetails = repo.GetBotStatus();
StatusDetail dbDetails = await repo.GetDbStatus();
StatusDetail cacheDetails = repo.GetCacheStatus();
return(Ok(new
{
botStatus = botDetails,
dbStatus = dbDetails,
cacheStatus = cacheDetails,
loginsInLast15Minutes = currentLogins,
defaultLanguage = _config.GetDefaultLanguage(),
trackedInvites = await InviteRepository.CreateDefault(_serviceProvider).CountInvites(),
modCases = await ModCaseRepository.CreateDefault(_serviceProvider, currentIdentity).CountAllCases(),
guilds = await GuildConfigRepository.CreateDefault(_serviceProvider).CountGuildConfigs(),
automodEvents = await AutoModerationEventRepository.CreateDefault(_serviceProvider).CountEvents(),
userNotes = await UserNoteRepository.CreateWithBotIdentity(_serviceProvider).CountUserNotes(),
userMappings = await UserMapRepository.CreateWithBotIdentity(_serviceProvider).CountAllUserMaps(),
apiTokens = await TokenRepository.CreateDefault(_serviceProvider).CountTokens(),
nextCache = _scheduler.GetNextCacheSchedule(),
cachedDataFromDiscord = _discordAPI.GetCache().Keys
}));
}
public AuthenticationController(UserRepository userRepository, TokenRepository tokenRepository,
IAuthenticator authenticator)
{
this.userRepository = userRepository;
this.tokenRepository = tokenRepository;
this.authenticator = authenticator;
}
public override void OnActionExecuting(HttpActionContext filterContext)
{
// Get API key provider
var provider = new TokenRepository();
if (filterContext.Request.Headers.Contains(Token))
{
var tokenValue = filterContext.Request.Headers.GetValues(Token).First();
// Validate Token
if (provider != null && !provider.ValidateToken(tokenValue))
{
var responseMessage = new HttpResponseMessage(HttpStatusCode.Unauthorized)
{
ReasonPhrase = "Invalid Request"
};
filterContext.Response = responseMessage;
}
}
else
{
filterContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
base.OnActionExecuting(filterContext);
}
public IActionResult ConfirmPasswordReset(string token)
{
var repository = new TokenRepository();
var existingToken = repository.All(token);
return(View("Index", existingToken));
}
private void Login(string key)
{
var tokenRepository = new TokenRepository();
var token = tokenRepository.GetToken(key);
BusinessPrincipal.LoadPrincipal(token.UserName);
}
public AuthorizationProvider(ClientRepository clientRepository, UserRepository userRepository,
TokenRepository tokenRepository)
{
_clientRepository = clientRepository;
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public AdminController(AdminRepository repository, IMapper <Admin, AdminWithPassword> mapper, AccountService accountService, TokenRepository tokenRepository)
{
_repository = repository;
_mapper = mapper;
_accountService = accountService;
_tokenRepository = tokenRepository;
}
public AccessToken ExchangeRequestTokenForAccessToken(string verificationCode)
{
var requestToken = TokenRepository.GetRequestToken();
if (requestToken == null)
{
throw new ApplicationException("The current TokenRepository doesn't have a current request token");
}
AccessToken token = BuildExchangeRequestTokenForAccessTokenContext(requestToken, verificationCode)
.Select(collection =>
new AccessToken
{
ConsumerKey = requestToken.ConsumerKey,
Token = ParseResponseParameter(collection, Parameters.OAuth_Token),
TokenSecret = ParseResponseParameter(collection, Parameters.OAuth_Token_Secret),
#pragma warning disable CS0612 // Type or member is obsolete
SessionHandle = ParseResponseParameter(collection, Parameters.OAuth_Session_Handle),
#pragma warning restore CS0612 // Type or member is obsolete
SessionExpiresIn = ParseResponseParameter(collection, Parameters.OAuth_Authorization_Expires_In),
ExpiresIn = ParseResponseParameter(collection, Parameters.OAuth_Expires_In),
CreatedDateUtc = DateTime.UtcNow
});
AssertValidAccessToken(token);
TokenRepository.SaveAccessToken(token);
return(token);
}
public async void GetUserIdByToken_AddTokenWithUserId1AndGetUserId_Returns1()
{
var mockDbContext = new Mock <DatabaseContext>();
var mockDbSetOfTokens = new Mock <DbSet <Token> >();
Guid guid = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
string strToken = "Token";
IQueryable <Token> data = new List <Token>()
{
new Token()
{
Id = guid, StrToken = strToken, UserId = guid2
},
}.AsQueryable();
mockDbSetOfTokens.As <IQueryable <Token> >().Setup(m => m.Provider).Returns(
new TestAsyncQueryProvider <Token>(data.Provider)
);
mockDbSetOfTokens.As <IQueryable <Token> >().Setup(m => m.Expression).Returns(data.Expression);
mockDbSetOfTokens.As <IQueryable <Token> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockDbSetOfTokens.As <IQueryable <Token> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
mockDbContext.Setup(a => a.Tokens).Returns(mockDbSetOfTokens.Object);
var tokenRepo = new TokenRepository(mockDbContext.Object);
var result = await tokenRepo.GetUserIdByToken(strToken);
Assert.Equal(guid2, result);
}
public AccountService(LoginService loginService, TokenService tokenService, UserRepository userRepository, TokenRepository tokenRepository)
{
_loginService = loginService;
_tokenService = tokenService;
_userRepository = userRepository;
_tokenRepository = tokenRepository;
}
public AuthorizationFilter(IConfiguration config, ILogger <AuthorizationFilter> logger, TokenRepository tokenRepository, IUserService userService)
{
_config = config;
_logger = logger;
_tokenRepository = tokenRepository;
_userService = userService;
}
public void GetByIdTest()
{
var repo = new TokenRepository(InitializeData());
var someToken = repo.GetById(1);
Assert.AreEqual(1, someToken.ID);
}
private static void Main(string[] args)
{
using (var repo = new az.tweetstore.ftp.Repository())
{
var frc = new FlowRuntimeConfiguration()
.AddStreamsFrom("az.receiver.application.root.flow", Assembly.GetExecutingAssembly())
.AddAction <string>("dequeue",
new IronMQOperations("AppZwitschern",
TokenRepository.LoadFrom("ironmq.credentials.txt")).Dequeue)
.AddFunc <string, Versandauftrag>("deserialize", new Serialization <Versandauftrag>().Deserialize)
.AddAction <Versandauftrag>("speichern", repo.Store);
using (var fr = new FlowRuntime(frc))
{
fr.Message += Console.WriteLine;
fr.UnhandledException += e =>
{
Console.WriteLine(e.InnerException);
fr.Process(new Message(".stop")
{
Priority = 99
});
};
fr.Process(".start");
fr.WaitForResult();
}
}
}
public void DisposeTest()
{
var repo = new TokenRepository(InitializeData());
repo.Dispose();
Assert.IsNull(repo.Tokens);
}
private static void Main(string[] args)
{
var twitter = new Twitter(TokenRepository.LoadFrom("twitter.consumer.token.txt"));
var url = twitter.GetAuthorizationUrl();
Console.WriteLine(url);
Process.Start(url);
Console.Write("Bitte geben Sie die PIN aus dem Browserfenster ein: ");
var pin = Console.ReadLine();
var accessToken = twitter.GetAccessToken(pin);
Console.Write("Access key: ");
Console.WriteLine(accessToken.Key);
Console.Write("Access secret: ");
Console.WriteLine(accessToken.Secret);
TokenRepository.SaveTo("twitter.access.token.txt", accessToken);
Console.WriteLine("Token gespeichert in twitter.access.token.txt");
Console.WriteLine("Mit Enter beenden...");
Console.ReadLine();
}
public string GetToken(string username, string password)
{
string result;
try
{
using (var dbContext = new WCFDBContext())
{
UserModel _user = new UserModel()
{
UserName = username,
Password = password
};
IUserRepository validator = new UserRepository(dbContext);
if (!validator.VerifyUser(_user))
{
throw new InvalidCredentialException("Invalid credentials");
}
result = new TokenRepository(dbContext).GetToken(_user).Message;
}
}
catch (Exception ex)
{
result = ex.Message;
}
return(result);
}
public TokenController(ServiceRepository serviceRepository, MerchantRepository merchantRepository,
PaymentInstrumentRepository paymentInstrumentRepository, TokenRepository tokenRepository)
{
_serviceRepository = serviceRepository;
_merchantRepository = merchantRepository;
_paymentInstrumentRepository = paymentInstrumentRepository;
_tokenRepository = tokenRepository;
}
public void BlackListTest()
{
var repo = new TokenRepository(InitializeData());
var someToken = repo.BlackList(1);
var blacklistedToken = repo.GetById(1);
Assert.IsTrue(blacklistedToken.BlackListed);
}
public void CheckConstructorWithParameters_CheckNullableLocalizationRepository_ShouldThrowException()
{
// Arrange
var tokenRepository = new TokenRepository();
// Assert
Assert.Throws <ArgumentNullException>(() => new LocalApi(tokenRepository, null));
}
public ActionResult A(IOAuthContext context)
{
var tokenRepository = new TokenRepository();
var tokenStore = new SampleMemoryTokenStore(tokenRepository);
var t = tokenStore.CreateRequestToken(context);
return new EmptyResult();
}
public DataAccess()
{
PollAppDBContext context = new PollAppDBContext();
UserRepository = new UserRepository(context);
CategoryRepository = new CategoryRepository(context);
TokenRepository = new TokenRepository(context);
QuestionRepository = new QuestionRepository(context);
AnswerRepository = new AnswerRepository(context);
FormRepository = new FormRepository(context);
VotedFormsRepository = new VotedFormsRepository(context);
}
public void SetUp()
{
_repository = new TokenRepository();
}
public AccountController(TokenRepository tokenRepository)
{
_tokenRepository = tokenRepository;
}
public HomeController(TokenRepository repository)
{
_repository = repository;
}
