public UserTaskService(RestService restService, IDbContext dbContext,ITokenProvider tokenProvider, IUserPreferenceService userPreferenceService)
{
_restService = restService;
_dbContext = dbContext;
var _authToken = tokenProvider.GetCurrentToken().Result;
_currentLoggedInUser = userPreferenceService.GetUserByEmailId(_authToken.Email).Result;
}
public CachingTokenProvider(ITokenProvider innerTokenProvider)
{
if (innerTokenProvider == null)
{
throw new ArgumentNullException(nameof(innerTokenProvider));
}
this.innerTokenProvider = innerTokenProvider;
}
/// <summary>
/// Create an access token credentials object, given an interface to a token source.
/// </summary>
/// <param name="tokenProvider">The source of tokens for these credentials.</param>
public TokenCredentials(ITokenProvider tokenProvider)
{
if (tokenProvider == null)
{
throw new ArgumentNullException("tokenProvider");
}
this.TokenProvider = tokenProvider;
}
public UsersApiIdentityManagerService(string identityServerUri, string usersApiUri, ITokenProvider tokenProvider)
{
if (tokenProvider == null)
{
throw new ArgumentNullException(nameof(tokenProvider));
}
this.tokenProvider = tokenProvider;
this.usersApiUri = usersApiUri;
this.identityServerUri = identityServerUri;
}
public V2BuildingService()
{
string clientId = ConfigurationManager.AppSettings["JciClientId"];
string clientSecret = ConfigurationManager.AppSettings["JciClientSecret"];
string tokenEndpoint = ConfigurationManager.AppSettings["JciTokenEndpoint"];
string buildingApiEndpoint = ConfigurationManager.AppSettings["JciBuildingApiEndpoint"];
IWebProxy proxy = WebProxy.GetDefaultProxy();
_tokenProvider = new ClientCredentialsTokenClient(clientId, clientSecret, tokenEndpoint, proxy);
_api = new ApiClient(_tokenProvider, buildingApiEndpoint);
}
/// <summary>
/// Create an IAccessApiFactory using the specified Url and Token Provider
/// </summary>
public static IAccessApiFactory Build(string url, ITokenProvider tokenProvider)
{
// TokenProviderConfiguration.ApiClient is the client used by AccessApiFactory and is
// NOT thread-safe, so there needs to be a separate instance for each instance of AccessApiFactory.
// Do NOT cache the AccessApiFactory instances (DEV-6922)
var config = new TokenProviderConfiguration(tokenProvider)
{
BasePath = url
};
return(new AccessApiFactory(config));
}
public UsersController(ITokenProvider tokenProvider,
IUserRepository userRepository,
IMapper mapper,
IHashGenerator hashGenerator,
ILogger <UsersController> logger)
{
this.tokenProvider = tokenProvider;
this.userRepository = userRepository;
this.mapper = mapper;
this.hashGenerator = hashGenerator;
this.logger = logger;
}
/// <summary>
/// Query for a token object at path <paramref name="path"/> as type <typeparamref name="T"/>.
/// </summary>
/// <param name="tokenContainer"></param>
/// <param name="path">(optional) path to query token at</param>
/// <param name="key">(optional) key to query, typically <see cref="Type.FullName"/></param>
/// <param name="token">array of tokens, or null if failed to find matching tokens</param>
/// <returns>true if tokens were found for the parameters</returns>
public static bool TryGetToken <T>(this IOption tokenContainer, string path, string key, out T token)
{
object obj;
ITokenProvider tp = tokenContainer.AsOption <ITokenProvider>();
if (tp != null && tp.TryGetToken(path, key, out obj) && obj is T casted)
{
token = casted; return(true);
}
token = default;
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyVaultSecretsProvider"/> class.
/// </summary>
/// <param name="secretsProviderOptions">A reference to the secrets provider options.</param>
/// <param name="tokenProvider">A reference to the token provider service to use to obtain access to the vault.</param>
/// <param name="logger">A logger for this provider.</param>
public KeyVaultSecretsProvider(
IOptions <KeyVaultSecretsProviderOptions> secretsProviderOptions,
ITokenProvider tokenProvider,
ILogger logger)
{
secretsProviderOptions?.Value.ThrowIfNull(nameof(secretsProviderOptions));
tokenProvider.ThrowIfNull(nameof(tokenProvider));
this.BaseUri = new Uri(secretsProviderOptions.Value.VaultBaseUrl);
this.keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(tokenProvider.TokenCallback));
this.Logger = logger.ForContext <KeyVaultSecretsProvider>();
}
public BrokeredMessageSenderPool(ServiceBusOptions serviceBusOptions)
{
if (serviceBusOptions == null)
{
throw new ArgumentNullException(nameof(serviceBusOptions), $"Service Bus options are required to use {nameof(BrokeredMessageSenderPool)}");
}
_senders = new ConcurrentDictionary <(string, (ServiceBusConnection, string)), ConcurrentQueue <MessageSender> >();
_retryPolicy = serviceBusOptions.Policy;
_connectionStringBuilder = new ServiceBusConnectionStringBuilder(serviceBusOptions.ConnectionString);
_tokenProvider = serviceBusOptions.TokenProvider;
}
public AccessTokenCleanupJob(
IConfiguration config,
ILogger <AccessTokenCleanupJob> logger,
ITokenProvider tokenProvider)
{
_tokenProvider = tokenProvider;
Schedule = CrontabSchedule.Parse(config.GetCron(nameof(AccessTokenCleanupJob)));
NextRun = Schedule.GetNextOccurrence(DateTime.Now);
Logger = logger;
}
private AmqpEventHubClient(EventHubsConnectionStringBuilder csb, ITokenProvider tokenProvider)
: base(csb)
{
ContainerId = Guid.NewGuid().ToString("N");
AmqpVersion = new Version(1, 0, 0, 0);
MaxFrameSize = AmqpConstants.DefaultMaxFrameSize;
InternalTokenProvider = tokenProvider;
CbsTokenProvider = new TokenProviderAdapter(this);
ConnectionManager = new FaultTolerantAmqpObject <AmqpConnection>(CreateConnectionAsync, CloseConnection);
_managementServiceClient = new Lazy <AmqpServiceClient>(CreateAmpqServiceClient);
}
public AccountService(IUnitOfWork unitOfWork, IAuthenticationManager authenticationManager,
ApplicationUserManager userManager, ITokenProvider tokenProvider)
{
_unitOfWork = unitOfWork;
_authenticationManager = authenticationManager;
_userManager = userManager;
_tokenProvider = tokenProvider;
if (_firstRun)
{
EnsureAdminExists(adminUsername: Constants.AdminUsername, adminEmail: "*****@*****.**");
}
}
public NativeAuthProvider(IMapper mapper,
IUserRepository userRepository,
ISessionRefreshTokenRepository sessionRefreshTokenRepository,
IPasswordHasher <User> passwordHasher,
ITokenProvider tokenProvider)
{
_mapper = mapper;
_userRepository = userRepository;
_passwordHasher = passwordHasher;
_tokenProvider = tokenProvider;
_sessionRefreshTokenRepository = sessionRefreshTokenRepository;
}
public ApiAuthClientFactory(
IOptions <SiteOptions> siteOptions,
ILogger <ApiAuthClientFactory> logger, IHttpClientFactory httpClientFactory, ITokenProvider tokenProvider, IHttpContextAccessor httpContextAccessor)
{
_logger = logger;
_siteOptions = siteOptions.Value;
_httpClientFactory = httpClientFactory;
_sharedClient =
new Lazy <HttpClient>(() => CreateHttpClient());
_tokenProvider = tokenProvider;
_httpContextAccessor = httpContextAccessor;
}
public void InitializeTest()
{
JsonConvert.DefaultSettings = () => new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
};
_httpClient = new HttpClientMock();
_tokenProvider = new TokenProviderMock();
((TokenProviderMock)_tokenProvider).RegisterHttpClientMock(_httpClient);
}
/// <summary>
/// Creates a new instance of the Subscription client using the specified endpoint, entity path, and token provider.
/// </summary>
/// <param name="endpoint">Fully qualified domain name for Service Bus. Most likely, {yournamespace}.servicebus.windows.net</param>
/// <param name="topicPath">Topic path.</param>
/// <param name="subscriptionName">Subscription name.</param>
/// <param name="tokenProvider">Token provider which will generate security tokens for authorization.</param>
/// <param name="transportType">Transport type.</param>
/// <param name="receiveMode">Mode of receive of messages. Defaults to <see cref="ReceiveMode"/>.PeekLock.</param>
/// <param name="retryPolicy">Retry policy for subscription operations. Defaults to <see cref="RetryPolicy.Default"/></param>
/// <remarks>Creates a new connection to the subscription, which is opened during the first receive operation.</remarks>
public SubscriptionClient(
string endpoint,
string topicPath,
string subscriptionName,
ITokenProvider tokenProvider,
TransportType transportType = TransportType.Amqp,
ReceiveMode receiveMode = ReceiveMode.PeekLock,
RetryPolicy retryPolicy = null)
: this(new ServiceBusConnection(endpoint, transportType, retryPolicy) { TokenProvider = tokenProvider }, topicPath, subscriptionName, receiveMode, retryPolicy)
{
this.OwnsConnection = true;
}
public DefaultUserInfoProvider(
HttpClient httpClient,
ITokenProvider tokenProvider,
IConfiguration configuration,
ILogger <DefaultUserInfoProvider> logger
)
{
this.httpClient = httpClient;
this.tokenProvider = tokenProvider;
this.configuration = configuration;
this.logger = logger;
}
public IEnumerable <WindowsAzureSubscription> AddAccount(ITokenProvider tokenProvider, PSCredential credential)
{
if (ActiveDirectoryEndpoint == null || ActiveDirectoryServiceEndpointResourceId == null)
{
throw new Exception(string.Format(Resources.EnvironmentDoesNotSupportActiveDirectory, Name));
}
IAccessToken mainToken;
if (credential != null)
{
mainToken = tokenProvider.GetNewToken(this, credential.UserName, credential.Password);
}
else
{
mainToken = tokenProvider.GetNewToken(this);
}
var credentials = new TokenCloudCredentials(mainToken.AccessToken);
using (var subscriptionClient = AddRestLogHandler(AddUserAgent(new SubscriptionClient(credentials, new Uri(ServiceEndpoint)))))
{
var result = subscriptionClient.Subscriptions.List();
// Filter out subscriptions with no tenant, backfill's not done on them
foreach (var subscription in result.Subscriptions.Where(s => !string.IsNullOrEmpty(s.ActiveDirectoryTenantId)))
{
var azureSubscription = new WindowsAzureSubscription
{
ActiveDirectoryEndpoint = ActiveDirectoryEndpoint,
ActiveDirectoryTenantId = subscription.ActiveDirectoryTenantId,
ActiveDirectoryUserId = mainToken.UserId,
ActiveDirectoryServiceEndpointResourceId = ActiveDirectoryServiceEndpointResourceId,
SubscriptionId = subscription.SubscriptionId,
SubscriptionName = subscription.SubscriptionName,
ServiceEndpoint = !string.IsNullOrEmpty(ServiceEndpoint) ? new Uri(ServiceEndpoint) : null,
ResourceManagerEndpoint = !string.IsNullOrEmpty(ResourceManagerEndpoint) ? new Uri(ResourceManagerEndpoint) : null,
TokenProvider = tokenProvider,
GalleryEndpoint = !string.IsNullOrEmpty(GalleryEndpoint) ? new Uri(GalleryEndpoint) : null,
SqlDatabaseDnsSuffix = SqlDatabaseDnsSuffix ?? WindowsAzureEnvironmentConstants.AzureSqlDatabaseDnsSuffix,
};
if (mainToken.LoginType == LoginType.LiveId)
{
azureSubscription.SetAccessToken(tokenProvider.GetNewToken(azureSubscription, mainToken.UserId));
}
else
{
azureSubscription.SetAccessToken(mainToken);
}
yield return(azureSubscription);
}
}
}
public AutenticarUseCaseTests()
{
this.clienteRepository = Substitute.For <IClienteRepository>();
this.clienteRepository.ObterPorCpf("123456789").Returns(Cliente.Carregar(Guid.NewGuid(), "Gustavo Martins Oliveira", "12345678", new Senha("minh@senh@Forte")));
this.tokenProvider = new JwtTokenProvider(new TokenConfigurations()
{
Audience = "DbServer",
Issuer = "DbServer",
Seconds = 60
}, new SigningConfigurations());
}
/// <summary>
/// Creates the instance with default providers and configuration
/// </summary>
public TokenAuthorisationService()
{
// create default
tokenProvider = new EncryptionTokenProvider(
new StringCryptoTransformer(
new NameValueSectionConfigurationProvider(ConfigSectionsResource.DefaultStringEncryptorSectionName)),
new NameValueSectionConfigurationProvider(ConfigSectionsResource.DefaultEncryptionTokenProviderSectionName));
tokenVerifier = new EncryptionTokenVerifier(
new StringCryptoTransformer(
new NameValueSectionConfigurationProvider(ConfigSectionsResource.DefaultStringEncryptorSectionName)),
new TokenDateTimeVerifier());
}
public Scanner(IOptions <ScannerOptions> opts, ITokenProvider tokenProvider, IHttpClientFactory httpFactory, ILoggerFactory loggerFactory)
{
_tokenProvider = tokenProvider;
_httpClient = httpFactory.CreateClient();
_log = loggerFactory.CreateLogger <Scanner>();
_opts = opts.Value;
_subscriptionIds = new List <string>()
{
_opts.DefaultSubscriptionId
};
_managementAzureAdResourceId = _opts.ManagementResourceId;
_managementEndpoint = _opts.ManagementEndpoint;
}
private User convertUserDtoToUserModel(UserDto dto)
{
ITokenProvider tokenProvider = httpClient.GetTokenProvider();
return(new User
{
UserId = dto.UserId,
UserTypeId = dto.UserTypeId,
Name = dto.Name,
UserCreatedOn = dto.UserCreatedOn,
Token = tokenProvider.GetToken().AccessValue
});
}
public NestedDeviceScopeApiClient(
string iotHubHostName,
string deviceId,
string moduleId,
Option <string> continuationToken,
int batchSize,
ITokenProvider edgeHubTokenProvider,
IServiceIdentityHierarchy serviceIdentityHierarchy,
Option <IWebProxy> proxy,
RetryStrategy retryStrategy = null)
: this(iotHubHostName, deviceId, deviceId, moduleId, continuationToken, batchSize, edgeHubTokenProvider, serviceIdentityHierarchy, proxy, retryStrategy)
{
}
public WSGameServerConnection(
ILogger logger,
IAppSettings settings,
ITokenProvider tokenProvider,
IGamePacketSerializer packetSerializer,
GameManager gameManager)
{
this.logger = logger;
this.settings = settings;
this.tokenProvider = tokenProvider;
this.packetSerializer = packetSerializer;
this.gameManager = gameManager;
}
/// <summary>
/// Create an ArcGIS Server gateway to access secure resources
/// </summary>
/// <param name="rootUrl">Made up of scheme://host:port/site</param>
/// <param name="serializer">Used to (de)serialize requests and responses</param>
/// <param name="tokenProvider">Provide access to a token for secure resources</param>
public PortalGatewayBase(String rootUrl, ISerializer serializer = null, ITokenProvider tokenProvider = null)
{
RootUrl = rootUrl.AsRootUrl();
TokenProvider = tokenProvider;
Serializer = serializer ?? SerializerFactory.Get();
if (Serializer == null)
{
throw new ArgumentNullException("serializer", "Serializer has not been set.");
}
_httpClient = HttpClientFactory.Get();
System.Diagnostics.Debug.WriteLine("Created PortalGateway for " + RootUrl);
}
/// <inheritdoc />
public DefaultTokenProviderChain(IConfiguration config = null, ILogger logger = null)
{
_logger = logger;
config = config ?? new ConfigurationBuilder().AddEnvironmentVariables().Build();
var providers = new List <ITokenProvider>
{
new ServicePrincipalTokenProvider(config: config, logger: logger),
new ManagedIdentityTokenProvider(config: config, logger: logger),
new SharedTokenCacheProvider(config: config, logger: logger)
};
_chain = new TokenProviderChain(providers);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicsCrmClient"/> class.
/// </summary>
/// <param name="uniqueName">The unique name of the Dynamics 365 CRM instance.</param>
/// <param name="domainName">The domain name of the Dynamics 365 CRM instance.</param>
/// <param name="tokenProvider">The token provider to use for acquiring access tokens.</param>
public DynamicsCrmClient(string uniqueName, string domainName, ITokenProvider tokenProvider)
: base(tokenProvider)
{
_uniqueName = uniqueName;
_domainName = domainName;
_audience = _audienceFormat.Replace("{domainName}", _domainName);
_baseAddress = _baseAddressFormat.Replace("{audience}", _audience);
JsonConvert.DefaultSettings = () => new JsonSerializerSettings()
{
ContractResolver = new JsonCamelCaseContractResolver(),
};
}
/// <summary>
/// Create a new <see cref="PortalGateway"/> using the default token service as discovered using the Info operation for the server
/// </summary>
/// <param name="rootUrl"></param>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="serializer"></param>
/// <param name="httpClientFunc"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static new async Task <PortalGateway> Create(
string rootUrl, string username, string password,
ISerializer serializer = null, Func <HttpClient> httpClientFunc = null,
CancellationToken ct = default(CancellationToken), string referer = null)
{
if (string.IsNullOrWhiteSpace(rootUrl))
{
throw new ArgumentNullException(nameof(rootUrl), "rootUrl is null.");
}
var gateway = new PortalGateway(rootUrl, serializer: serializer, httpClientFunc: httpClientFunc);
var info = await gateway.Info(ct);
if (info == null)
{
throw new Exception($"Unable to get ArcGIS Server information for {gateway.RootUrl}. Check the ArcGIS Server URL and try again.");
}
ITokenProvider tokenProvider = null;
if (!string.IsNullOrWhiteSpace(info.OwningSystemUrl) && (info.OwningSystemUrl.StartsWith("http://www.arcgis.com", StringComparison.OrdinalIgnoreCase) || info.OwningSystemUrl.StartsWith("https://www.arcgis.com", StringComparison.OrdinalIgnoreCase)))
{
tokenProvider = new ArcGISOnlineTokenProvider(username, password, serializer: serializer, httpClientFunc: httpClientFunc, referer: referer);
}
else
{
if (!string.IsNullOrWhiteSpace(info.AuthenticationInfo?.TokenServicesUrl))
{
if (!info.AuthenticationInfo.TokenServicesUrl.StartsWith(gateway.RootUrl, StringComparison.OrdinalIgnoreCase))
{
tokenProvider = new FederatedTokenProvider(
new ServerFederatedWithPortalTokenProvider(info.AuthenticationInfo.TokenServicesUrl.Replace("/generateToken", ""), username, password, serializer: serializer, httpClientFunc: httpClientFunc, referer: referer),
info.AuthenticationInfo.TokenServicesUrl.Replace("/generateToken", ""),
gateway.RootUrl,
referer: info.AuthenticationInfo.TokenServicesUrl.Replace("/sharing/rest/generateToken", "/rest"),
serializer: serializer,
httpClientFunc: httpClientFunc);
}
else
{
tokenProvider = new TokenProvider(info.AuthenticationInfo?.TokenServicesUrl, username, password, serializer: serializer, httpClientFunc: httpClientFunc, referer: referer);
}
}
}
return(new PortalGateway(
rootUrl,
tokenProvider: tokenProvider,
serializer: serializer,
httpClientFunc: httpClientFunc));
}
public TokenCache(
ITokenProvider tokenProvider,
TimeSpan buffer,
CancellationToken ct)
{
if (buffer < TimeSpan.Zero)
{
throw new ArgumentException("Buffer must be a positive value");
}
_tokenProvider = tokenProvider;
_buffer = buffer;
_semaphore = new SemaphoreSlim(1, 1);
}
public ApiClient(string baseUrl, ITokenProvider tokenProvider)
{
this.baseUrl = baseUrl;
this.tokenProvider = tokenProvider;
var token = tokenProvider.GetToken();
if (token != null)
{
this.refreshToken = token.RefreshToken;
this.accessToken = token.AccessToken;
this.accessTokenExpires = token.Expires;
}
}
public bool ShouldAuthenticate()
{
try
{
ITokenProvider tokenProvider = httpClient.GetTokenProvider();
tokenProvider.GetToken();
return(false);
}
catch (TokenExpiredException ex)
{
return(true);
}
}
public LoginModel(SignInManager <IdentityUser> signInManager,
ILogger <LoginModel> logger,
UserManager <IdentityUser> userManager,
IEmailSender emailSender,
ITokenProvider tokenProvider,
IOptions <SiteOptions> siteOptions)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_tokenProvider = tokenProvider;
_siteOptions = siteOptions.Value;
}
protected async Task <ICloudProxy> CreateNewCloudProxyAsync(ITokenProvider newTokenProvider)
{
IClient client = await this.ConnectToIoTHub(newTokenProvider);
ICloudProxy proxy = new CloudProxy(
client,
this.messageConverterProvider,
this.Identity.Id,
this.ConnectionStatusChangedHandler,
this.cloudListener,
this.idleTimeout,
this.closeOnIdleTimeout);
return(proxy);
}
public AmqpEventHubClient(
Uri endpointAddress,
string entityPath,
ITokenProvider tokenProvider,
TimeSpan operationTimeout,
EventHubs.TransportType transportType)
: base(new EventHubsConnectionStringBuilder(endpointAddress, entityPath, operationTimeout, transportType))
{
this.ContainerId = Guid.NewGuid().ToString("N");
this.AmqpVersion = new Version(1, 0, 0, 0);
this.MaxFrameSize = AmqpConstants.DefaultMaxFrameSize;
this.InternalTokenProvider = tokenProvider;
this.CbsTokenProvider = new TokenProviderAdapter(this);
this.ConnectionManager = new FaultTolerantAmqpObject <AmqpConnection>(this.CreateConnectionAsync, this.CloseConnection);
}
/// <summary>
/// Initializes a new instance of the <see cref="OauthEvoRestfulClient"/> class.
/// </summary>
/// <param name="tokenProvider">The token provider.</param>
/// <param name="oauthIdentity">The oauth identity.</param>
public OauthEvoRestfulClient(ITokenProvider tokenProvider, OAuthTokenIdentifier oauthIdentity)
{
if (tokenProvider == null)
{
throw new ArgumentNullException(nameof(tokenProvider), "The parameter named tokenProvider can't be null.");
}
this.m_tokenProvider = tokenProvider;
HttpClientHandler handler = new HttpClientHandler();
handler.AllowAutoRedirect = false;
m_httpClient = new HttpClient(handler);
m_httpClient.Timeout = TimeSpan.FromSeconds(30);
m_oauthIdentity = oauthIdentity;
}
public static void Initialize(ITokenProvider provider)
{
// Create the HttpClient with a cookie container for authentication
CookieContainer = new CookieContainer();
HttpClientHandler handler = new HttpClientHandler();
handler.CookieContainer = CookieContainer;
// The AuthenticationMessageHandler (see Auth/AuthenticationMessageHandler.cs) provides for transparent
// authentication with our backend using the token from the ITokenProvider given to its constructor.
// If the token is non-null, the backend applies that user's preferences to requests. In the implementation
// here, the provider is the Configuration.UserPreferences class, which must be initialized before now.
_httpClient = HttpClientFactory.Create(handler, new AuthenticationMessageHandler(provider));
BaseURI = new System.Uri(WebAPIConstants.BaseURI);
_httpClient.BaseAddress = BaseURI;
_httpClient.Timeout = TimeSpan.FromSeconds(WebAPIConstants.Timeout);
}
public static ITokenProvider GetTokenProvider()
{
Lock.EnterReadLock();
try
{
{
if (_provider == null)
{
if (Configuration.IsMock)
_provider = new MockTokenProvider();
else
_provider = new TokenProvider();
}
}
}
finally
{
Lock.ExitReadLock();
}
return _provider;
}
public TokenAuthenticationAttribute(AccessLevel accessLevel, ITokenProvider tokenProvider, List<ITokenFetcher> tokenFetchers)
{
if (tokenProvider == null)
{
throw new ArgumentNullException("tokenProvider");
}
if (tokenFetchers == null)
{
throw new ArgumentNullException("tokenFetchers");
}
if (!tokenFetchers.Any())
{
throw new ArgumentException("tokenFetchers cann't be empty", "tokenFetchers");
}
_accessLevel = accessLevel;
_tokenProvider = tokenProvider;
_tokenFetchers = tokenFetchers;
}
public ProvisionController(ITokenProvider provisioner, IDeviceRegistry registry)
{
_provisioner = provisioner;
_registry = registry;
}
public BpipeAuthenticator(ITokenProvider tokenProvider)
{
_tokenProvider = tokenProvider;
}
public AccountRequest(Func<DisposableClient> clientFactory, ITokenProvider authorizeTokenProvider)
: base(clientFactory, authorizeTokenProvider)
{ }
/// <summary>
/// Create an access token credentials object, given an interface to a token source.
/// </summary>
/// <param name="tokenProvider">The source of tokens for these credentials.</param>
/// <param name="tenantId">Tenant ID from AuthenticationResult</param>
/// <param name="callerId">UserInfo.DisplayableId field from AuthenticationResult</param>
public TokenCredentials(ITokenProvider tokenProvider, string tenantId, string callerId)
: this(tokenProvider)
{
this.TenantId = tenantId;
this.CallerId = callerId;
}
public TokenAuthorisationService(ITokenProvider tokenProvider, ITokenVerifier tokenVerifier) : this()
{
this.tokenProvider = tokenProvider;
this.tokenVerifier = tokenVerifier;
}
public AppViewModel(ITokenProvider tokenProvider, IAuthenticator authenticator)
{
_tokenProvider = tokenProvider;
_authenticator = authenticator;
}
/// <summary>
/// Initializes a new instance of the <see cref="OAuthDataServiceAdapter"/> class.
/// </summary>
/// <param name="tokenProvider">Azure Media Services token provider.</param>
public OAuthDataServiceAdapter(ITokenProvider tokenProvider)
{
_tokenProvider = tokenProvider;
}
public AuthenticationController(IDatabaseClient databaseClient, ITokenProvider tokenProvider)
{
this.databaseClient = databaseClient;
this.tokenProvider = tokenProvider;
}
public void SetTokenProvider(ITokenProvider tokenProvider)
{
_authorizeTokenProvider = tokenProvider;
}
public IEnumerable<WindowsAzureSubscription> AddAccount(ITokenProvider tokenProvider)
{
if (ActiveDirectoryEndpoint == null || ActiveDirectoryServiceEndpointResourceId == null)
{
throw new Exception(string.Format(Resources.EnvironmentDoesNotSupportActiveDirectory, Name));
}
IAccessToken mainToken = tokenProvider.GetNewToken(this);
var credentials = new TokenCloudCredentials(mainToken.AccessToken);
using (var subscriptionClient = new SubscriptionClient(credentials, new Uri(ServiceEndpoint)))
{
var result = subscriptionClient.Subscriptions.List();
// Filter out subscriptions with no tenant, backfill's not done on them
foreach (var subscription in result.Subscriptions.Where(s => !string.IsNullOrEmpty(s.ActiveDirectoryTenantId)))
{
var azureSubscription = new WindowsAzureSubscription
{
ActiveDirectoryEndpoint = ActiveDirectoryEndpoint,
ActiveDirectoryTenantId = subscription.ActiveDirectoryTenantId,
ActiveDirectoryUserId = mainToken.UserId,
ActiveDirectoryServiceEndpointResourceId = ActiveDirectoryServiceEndpointResourceId,
SubscriptionId = subscription.SubscriptionId,
SubscriptionName = subscription.SubscriptionName,
ServiceEndpoint = !string.IsNullOrEmpty(ServiceEndpoint) ? new Uri(ServiceEndpoint) : null,
ResourceManagerEndpoint = !string.IsNullOrEmpty(ResourceManagerEndpoint) ? new Uri(ResourceManagerEndpoint) : null,
TokenProvider = tokenProvider,
GalleryEndpoint = !string.IsNullOrEmpty(GalleryEndpoint) ? new Uri(GalleryEndpoint) : null
};
if (mainToken.LoginType == LoginType.LiveId)
{
azureSubscription.SetAccessToken(tokenProvider.GetNewToken(azureSubscription, mainToken.UserId));
}
else
{
azureSubscription.SetAccessToken(mainToken);
}
yield return azureSubscription;
}
}
}
public AuthenticationHandler(ITokenProvider tokenProvider)
{
_tokenProvider = tokenProvider;
}
/// <summary>
/// Initializes a new instance of the HomeController class.
/// </summary>
/// <param name="sampleSettings"></param>
public HomeController( ITokenProvider tokenProvider, SampleSettings sampleSettings )
{
this.tokenProvider = tokenProvider;
this.sampleSettings = sampleSettings;
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="tokenProvider">A token provider for authorization tokens</param>
public CloudMediaContext(ITokenProvider tokenProvider)
: this(_mediaServicesUri, tokenProvider)
{
}
public AdalTokenProvider(IWin32Window parentWindow)
{
this.userTokenProvider = new UserTokenProvider(parentWindow);
this.servicePrincipalTokenProvider = new ServicePrincipalTokenProvider();
}
/// <summary>
/// Create an instance of <see cref="WindowsAzureProfile"/> that
/// stores data in the given store.
/// </summary>
/// <param name="profileStore">Data store to read and write from.</param>
/// <param name="tokenProvider">Token provider used to look up Active Directory tokens</param>
public WindowsAzureProfile(IProfileStore profileStore, ITokenProvider tokenProvider)
{
this.profileStore = profileStore;
this.TokenProvider = tokenProvider;
Load();
}
public ProductSuggestRequest(Func<DisposableClient> clientFactory, ITokenProvider authorizeTokenProvider) :
base(clientFactory, authorizeTokenProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudMediaContext"/> class.
/// </summary>
/// <param name="apiServer">A <see cref="Uri"/> representing the API endpoint.</param>
/// <param name="tokenProvider">A token provider for authorization tokens.</param>
public CloudMediaContext(Uri apiServer, ITokenProvider tokenProvider)
{
_apiServer = apiServer;
TokenProvider = tokenProvider;
ParallelTransferThreadCount = 10;
NumberOfConcurrentTransfers = 2;
}
public AuthenticationMessageHandler(ITokenProvider provider)
{
_provider = provider;
}
public TokenClaimsFilter(ITokenProvider tokenProvider)
{
this.tokenProvider = tokenProvider;
}
public WelcomeViewModel(IAuthenticator authenticator, ITokenProvider tokenProvider)
{
_authenticator = authenticator;
_tokenProvider = tokenProvider;
LoginCommand = new Command(ExecuteLoginCommand);
}
