public Task <ManifestQueryResult> GetManifestAsync(string image, IRegistryCredentialsHost credsHost, bool isDryRun)
{
if (isDryRun)
{
return(Task.FromResult(new ManifestQueryResult("", new JsonObject())));
}
ImageName imageName = ImageName.Parse(image, autoResolveImpliedNames: true);
BasicAuthenticationCredentials?basicAuthCreds = null;
// Lookup the credentials, if any, for the registry where the image is located
if (credsHost.Credentials.TryGetValue(imageName.Registry !, out RegistryCredentials? registryCreds))
{
basicAuthCreds = new BasicAuthenticationCredentials
{
UserName = registryCreds.Username,
Password = registryCreds.Password
};
}
// Docker Hub's registry has a separate host name for its API
string apiRegistry = imageName.Registry == DockerHelper.DockerHubRegistry ?
DockerHelper.DockerHubApiRegistry :
imageName.Registry !;
RegistryServiceClient registryClient = new(apiRegistry, _httpClient, basicAuthCreds);
return(registryClient.GetManifestAsync(imageName.Repo, (imageName.Tag ?? imageName.Digest) !));
}
internal static T MakeApi <T>(AuthToken authToken, Func <ServiceClientCredentials, Uri, T> ctor) where T : ServiceClient <T>, IUiPathWebApi
{
ServiceClientCredentials creds = null;
if (authToken.Authenticated == false)
{
creds = new BasicAuthenticationCredentials();
}
else if (authToken.WindowsCredentials)
{
creds = new NetworkAuthenticationCredentials
{
Credentials = CredentialCache.DefaultNetworkCredentials
};
}
else
{
creds = new TokenCredentials(authToken.Token);
}
var api = ctor(creds, new Uri(authToken.URL));
api.SetRetryPolicy(null);
api.SerializationSettings.Converters.Add(new SpecificItemDtoConverter());
api.DeserializationSettings.Converters.Add(new KeyValuePairConverter());
if (authToken.OrganizationUnitId.HasValue)
{
api.HttpClient.DefaultRequestHeaders.Add("X-UIPATH-OrganizationUnitId", authToken.OrganizationUnitId.Value.ToString());
}
return(api);
}
public static IncidentAPIClient GetIncidentAPIClient()
{
ServiceClientCredentials creds = new BasicAuthenticationCredentials();
var client = new IncidentAPIClient(new Uri(Settings.INCIDENT_API_URL), creds);
return(client);
}
internal static ApiHelper FromTestContext(TestContext testContext)
{
var testSettings = TestSettings.FromTestContext(testContext);
var creds = new BasicAuthenticationCredentials();
using (var client = new UiPathWebApi(creds)
{
BaseUri = new Uri(testSettings.URL)
})
{
var loginModel = new LoginModel
{
TenancyName = testSettings.TenantName,
UsernameOrEmailAddress = testSettings.UserName,
Password = testSettings.Password
};
var response = client.Account.Authenticate(loginModel);
var token = (string)response.Result;
var tokenCreds = new TokenCredentials(token);
var api = new UiPathWebApi(tokenCreds)
{
BaseUri = new Uri(testSettings.URL)
};
return(new ApiHelper
{
_api = api
});
}
}
public static IDynamicsClient SetupDynamics(IConfiguration Configuration)
{
string dynamicsOdataUri = Configuration["DYNAMICS_ODATA_URI"];
string aadTenantId = Configuration["DYNAMICS_AAD_TENANT_ID"];
string serverAppIdUri = Configuration["DYNAMICS_SERVER_APP_ID_URI"];
string clientKey = Configuration["DYNAMICS_CLIENT_KEY"];
string clientId = Configuration["DYNAMICS_CLIENT_ID"];
string ssgUsername = Configuration["SSG_USERNAME"];
string ssgPassword = Configuration["SSG_PASSWORD"];
AuthenticationResult authenticationResult = null;
// authenticate using ADFS.
if (string.IsNullOrEmpty(ssgUsername) || string.IsNullOrEmpty(ssgPassword))
{
var authenticationContext = new AuthenticationContext(
"https://login.windows.net/" + aadTenantId);
ClientCredential clientCredential = new ClientCredential(clientId, clientKey);
var task = authenticationContext.AcquireTokenAsync(serverAppIdUri, clientCredential);
task.Wait();
authenticationResult = task.Result;
}
ServiceClientCredentials serviceClientCredentials = null;
if (string.IsNullOrEmpty(ssgUsername) || string.IsNullOrEmpty(ssgPassword))
{
var authenticationContext = new AuthenticationContext(
"https://login.windows.net/" + aadTenantId);
ClientCredential clientCredential = new ClientCredential(clientId, clientKey);
var task = authenticationContext.AcquireTokenAsync(serverAppIdUri, clientCredential);
task.Wait();
authenticationResult = task.Result;
string token = authenticationResult.CreateAuthorizationHeader().Substring("Bearer ".Length);
serviceClientCredentials = new TokenCredentials(token);
}
else
{
serviceClientCredentials = new BasicAuthenticationCredentials()
{
UserName = ssgUsername,
Password = ssgPassword
};
}
IDynamicsClient client = new DynamicsClient(new Uri(Configuration["DYNAMICS_ODATA_URI"]), serviceClientCredentials);
// set the native client URI
if (string.IsNullOrEmpty(Configuration["DYNAMICS_NATIVE_ODATA_URI"]))
{
client.NativeBaseUri = new Uri(Configuration["DYNAMICS_ODATA_URI"]);
}
else
{
client.NativeBaseUri = new Uri(Configuration["DYNAMICS_NATIVE_ODATA_URI"]);
}
return(client);
}
public DigicertRetailAPI(string username, string password) : this(new AddAcceptHeaderHandler())
{
Credentials = new BasicAuthenticationCredentials {
UserName = username, Password = password
};
Credentials.InitializeServiceClient(this);
}
public static IncidentAPIClient GetIncidentAPIClient()
{
ServiceClientCredentials creds = new BasicAuthenticationCredentials();
var client = new IncidentAPIClient(new Uri("YOUR INCIDENT API URL"), creds);
return(client);
}
/// <summary>
///
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="loginServer"></param>
/// <returns></returns>
public static async ValueTask <AcrRepository[]> LoadAsync(string userName, string password, string loginServer)
{
//--- create client
var credentials = new BasicAuthenticationCredentials
{
UserName = userName.Trim(),
Password = password.Trim(),
};
var client = new AzureContainerRegistryClient(credentials)
{
BaseUri = new Uri($"https://{loginServer.Trim()}"),
};
//--- load reposigories
var names = (await client.GetRepositoriesAsync().ConfigureAwait(false)).Names;
return((await names
.Select(async x =>
{
var manifests
= (await client.GetAcrManifestsAsync(x).ConfigureAwait(false))
.Manifests
.OrderByDescending(y => y.CreatedTime)
.Select(y => new AcrManifest(y))
.ToArray();
return new AcrRepository(x, manifests);
})
.WhenAll()
.ConfigureAwait(false))
.OrderBy(x => x.Name)
.ToArray());
}
private void GetLearners()
{
var credentials = new BasicAuthenticationCredentials();
credentials.UserName = "******";
credentials.Password = "******";
var l = new Learners(new PICSWeb());
var v = l.SearchAsync("Sha", "Aan", "");
List <DBLearner> dbLearners = null;
string surnameSearchText = EdSearchBarName.Text;
if (string.IsNullOrWhiteSpace(surnameSearchText))
{
dbLearners = Task.Run(() => App.DB.GetLearners()).Result;
}
else
{
dbLearners = Task.Run(() => App.DB.SearchLearnersByName(surnameSearchText)).Result;
}
Learners.Clear();
foreach (DBLearner learner in dbLearners)
{
Learners.Add(learner);
}
}
/// <summary>
/// Set credentials for the Client
/// </summary>
/// <param name="config">k8s client configuration</param>
/// <param name="handler">http client handler for the rest client</param>
/// <returns>Task</returns>
private void SetCredentials(KubernetesClientConfiguration config, HttpClientHandler handler)
{
// set the Credentails for token based auth
if (!string.IsNullOrWhiteSpace(config.AccessToken))
{
Credentials = new TokenCredentials(config.AccessToken);
}
else if (!string.IsNullOrWhiteSpace(config.Username) && !string.IsNullOrWhiteSpace(config.Password))
{
Credentials = new BasicAuthenticationCredentials
{
UserName = config.Username,
Password = config.Password
};
}
#if XAMARINIOS1_0 || MONOANDROID8_1
// handle.ClientCertificates is not implemented in Xamarin.
return;
#endif
if ((!string.IsNullOrWhiteSpace(config.ClientCertificateData) ||
!string.IsNullOrWhiteSpace(config.ClientCertificateFilePath)) &&
(!string.IsNullOrWhiteSpace(config.ClientCertificateKeyData) ||
!string.IsNullOrWhiteSpace(config.ClientKeyFilePath)))
{
var cert = CertUtils.GeneratePfx(config);
#if NET452
((WebRequestHandler)handler).ClientCertificates.Add(cert);
#else
handler.ClientCertificates.Add(cert);
#endif
}
}
private static ApiClient CreateApiClient()
{
var credentials = new BasicAuthenticationCredentials();
var client = new ApiClient(new Uri(ConfigurationManager.AppSettings["ApiBaseUrl"]), credentials);
return(client);
}
internal static UiPathWebApi MakeApi(AuthToken authToken)
{
ServiceClientCredentials creds = null;
if (authToken.Authenticated == false)
{
creds = new BasicAuthenticationCredentials();
}
else if (authToken.WindowsCredentials)
{
creds = new NetworkAuthenticationCredentials
{
Credentials = CredentialCache.DefaultNetworkCredentials
};
}
else
{
creds = new TokenCredentials(authToken.Token);
}
var api = new UiPathWebApi(creds)
{
BaseUri = new Uri(authToken.URL)
};
api.SetRetryPolicy(null);
api.SerializationSettings.Converters.Add(new SpecificItemDtoConverter());
return(api);
}
static void Main(string[] args)
{
// load the sample data - a list of countries scraped from Reuters articles
var lines = File.ReadAllLines(dataPath);
var countries = from l in lines select new Country()
{
Name = l
};
Console.WriteLine($"Found {countries.Count()} documents ready for indexing...");
// ask for the admin password, so I can safely store this code in github
Console.Write("Please provide password for Elastic cluster: ");
var password = Console.ReadLine();
// connect to elasticsearch using basic auth
var credentials = new BasicAuthenticationCredentials("elastic", password);
var cloudId = "Test:d2VzdGV1cm9wZS5henVyZS5lbGFzdGljLWNsb3VkLmNvbTo5MjQzJDI3MTE2MzJhMDBjZTRmNmZhNDE1MWU2ZmU2NDYxYTU3JDYwMGRhOTBhNDUwMzRmNmE4MDA5NDg2OWIxZDZhYmJi";
var settings = new ConnectionSettings(cloudId, credentials);
var client = new ElasticClient(settings);
// index the country objects using bulk indexing
var response = client.Bulk(b => b.Index("countries").IndexMany(countries));
// report any errors
if (response.Errors)
{
Console.WriteLine(response.ServerError.ToString());
}
else
{
Console.WriteLine($"Indexed {countries.Count()} new documents!");
}
}
public static IncidentAPIClient GetIncidentAPIClient()
{
ServiceClientCredentials creds = new BasicAuthenticationCredentials();
var client = new IncidentAPIClient(new Uri(CloudConfigurationManager.GetSetting("INCIDENT_API_URL")), creds);
return(client);
}
internal static UiPathWebApi MakeApi(AuthToken authToken)
{
ServiceClientCredentials creds = null;
if (authToken.Authenticated == false)
{
creds = new BasicAuthenticationCredentials();
}
else if (authToken.WindowsCredentials)
{
creds = new NetworkAuthenticationCredentials
{
Credentials = CredentialCache.DefaultNetworkCredentials
};
}
else
{
creds = new TokenCredentials(authToken.Token);
}
var api = new UiPathWebApi(creds)
{
BaseUri = new Uri(authToken.URL)
};
api.SetRetryPolicy(null);
api.SerializationSettings.Converters.Add(new SpecificItemDtoConverter());
if (authToken.OrganizationUnitId.HasValue)
{
api.HttpClient.DefaultRequestHeaders.Add("X-UIPATH-OrganizationUnitId", authToken.OrganizationUnitId.Value.ToString());
}
return(api);
}
/// <summary>
/// Set credentials for the Client
/// </summary>
/// <param name="config">k8s client configuration</param>
/// <param name="handler">http client handler for the rest client</param>
/// <returns>Task</returns>
private void SetCredentials(KubernetesClientConfiguration config, HttpClientHandler handler)
{
// set the Credentails for token based auth
if (!string.IsNullOrWhiteSpace(config.AccessToken))
{
Credentials = new TokenCredentials(config.AccessToken);
}
else if (!string.IsNullOrWhiteSpace(config.Username) && !string.IsNullOrWhiteSpace(config.Password))
{
Credentials = new BasicAuthenticationCredentials
{
UserName = config.Username,
Password = config.Password
};
}
// othwerwise set handler for clinet cert based auth
else if ((!string.IsNullOrWhiteSpace(config.ClientCertificateData) ||
!string.IsNullOrWhiteSpace(config.ClientCertificateFilePath)) &&
(!string.IsNullOrWhiteSpace(config.ClientCertificateKeyData) ||
!string.IsNullOrWhiteSpace(config.ClientKeyFilePath)))
{
var cert = CertUtils.GeneratePfx(config);
handler.ClientCertificates.Add(cert);
}
}
private AuthToken GetUserToken()
{
var creds = new BasicAuthenticationCredentials();
using (var client = new UiPathWebApi(creds)
{
BaseUri = new Uri(URL)
})
{
var loginModel = new LoginModel
{
TenancyName = TenantName,
UsernameOrEmailAddress = Username,
Password = Password
};
var response = HandleHttpOperationException(() => client.Account.Authenticate(loginModel));
var token = (string)response.Result;
return(new AuthToken
{
Token = token,
URL = URL,
WindowsCredentials = false,
Authenticated = true
});
}
}
public MatchPlayersController()
{
string strRealTimeChessUri = WebConfigurationManager.AppSettings["RealTimeChessUri"];
baseUri = new Uri(strRealTimeChessUri);
authCredsBasic = new BasicAuthenticationCredentials();
apiChess = new RealTimeChessAPI(baseUri, authCredsBasic);
}
private IUser GetUserForCredentials(BasicAuthenticationCredentials credentials, IMembershipService membershipService)
{
if ( credentials == null )
{
return null;
}
return membershipService.ValidateUser(credentials.Username, credentials.Password);
}
public RequireBasicAuthenticationAttribute(string basicRealm, string requiredUserName, string requiredPassword, IBasicAuthenticationProvider authenticator)
{
_basicRealm = basicRealm;
if (requiredUserName != null || requiredPassword != null)
{
_requiredCredentials = new BasicAuthenticationCredentials(requiredUserName, requiredPassword);
}
_authenticator = authenticator;
}
/// <summary>
/// Initializes a new instance of the HDInsightJobClient
/// class.
/// </summary>
/// <param name='clusterDnsName'>
/// Required. The cluster dns name against which the job management is
/// to be performed.
/// </param>
/// <param name='credentials'>
/// Required. Basic authentication credentials for job submission.
/// </param>
/// <param name='httpClient'>
/// The Http client
/// </param>
public HDInsightJobClient(string endpoint, BasicAuthenticationCredentials credentials, HttpClient httpClient, bool disposeHttpClient = true)
: this(httpClient, disposeHttpClient)
{
this.Endpoint = endpoint ?? throw new ArgumentNullException("endpoint");
this.Credentials = credentials ?? throw new ArgumentNullException("credentials");
this.Credentials.InitializeServiceClient(this);
this.Username = CultureInfo.CurrentCulture.TextInfo.ToLower(credentials.UserName);
}
/// <summary>
/// Create a client that connects to cloud, uses dotnet user-secrets.
/// </summary>
private static ElasticClient CreateCloudClient()
{
var userSecrets = new ConfigurationBuilder().AddUserSecrets <Program>().Build();
var basicAuth = new BasicAuthenticationCredentials(userSecrets["cloud:user"], userSecrets["cloud:password"]);
var connectionPool = new CloudConnectionPool(userSecrets["cloud:id"], basicAuth);
var settings = DefaultConnectionSettings(new ConnectionSettings(connectionPool));
return(new ElasticClient(settings));
}
public PlayerTypesController()
{
rootWebConfig1 = WebConfigurationManager.OpenWebConfiguration(null);
configRealTimeChessUri = rootWebConfig1.AppSettings.Settings["RealTimeChessUri"];
string strRealTimeChessUri = configRealTimeChessUri.Value;
baseUri = new Uri(strRealTimeChessUri);
authCredsBasic = new BasicAuthenticationCredentials();
apiChess = new RealTimeChessAPI(baseUri, authCredsBasic);
}
private static HDInsightJobManagementClient GetHDInsightUnitTestingJobClient()
{
var cred = new BasicAuthenticationCredentials()
{
UserName = "******",
Password = "******"
};
return(new HDInsightJobManagementClient("TestCluster", cred));
}
private HDInsightManagementClient GetHDInsightUnitTestingClient(TestDelegatingHandler handler)
{
ServiceClientCredentials cred = new BasicAuthenticationCredentials();
HDInsightManagementClient client = new HDInsightManagementClient(cred, handler)
{
SubscriptionId = Guid.NewGuid().ToString()
};
return(client);
}
public SearchClient(IConfiguration configuration)
{
var cloudId = configuration["ElasticCloudId"];
var username = configuration["ElasticUsername"];
var password = configuration["ElasticPassword"];
var basicCredentials = new BasicAuthenticationCredentials(username, password);
_connectionSettings = new ConnectionSettings(cloudId, basicCredentials);
_connectionSettings.DisableDirectStreaming().PrettyJson();
}
public void GetTablesTest()
{
BasicAuthenticationCredentials credentials = new BasicAuthenticationCredentials
{
UserName = "******",
Password = "******"
};
ActivitiRESTAPI api = new ActivitiRESTAPI(credentials);
var tables = api.GetTables();
}
private IUser getUserForCredentials(
BasicAuthenticationCredentials credentials,
IMembershipService membershipService)
{
if (credentials == null)
{
return(null);
}
return(membershipService.ValidateUser(credentials.Username, credentials.Password));
}
public static void Register(IUnityContainer container)
{
var credentials = new BasicAuthenticationCredentials()
{
UserName = ConfigurationManager.AppSettings["CollateralServiceApiLogin"],
Password = ConfigurationManager.AppSettings["CollateralServiceApiPassword"]
};
var baseUri = new Uri(ConfigurationManager.AppSettings["CollateralServiceApiEndpoint"]);
container.RegisterType <ICollateralServiceWebAPI, CollateralServiceWebAPI>(new InjectionConstructor(baseUri, credentials, new DelegatingHandler[0]));
}
public static void Register(IUnityContainer container)
{
var credentials = new BasicAuthenticationCredentials();
credentials.UserName = ConfigurationManager.AppSettings["DictionariesApiLogin"];
credentials.Password = ConfigurationManager.AppSettings["DictionariesApiPassword"];
var dictionariesClient = new Dictionaries.DictionariesClient(new Uri(ConfigurationManager.AppSettings["DictionariesApiEndpoint"]), credentials);
container
.RegisterType <Dictionaries.IDictionaryOperations, Dictionaries.DictionaryOperations>(new InjectionConstructor(dictionariesClient));
}
/// <summary>
/// Initializes a new instance of the HDInsightJobClient
/// class.
/// <param name='credentials'>
/// Required. Basic authentication credentials for job submission.
/// </param>
/// </summary>
/// <param name='clusterDnsName'>
/// Required. The cluster dns name against which the job management is
/// to be performed.
/// </param>
/// <param name='userName'>
/// Required. The user name used for running job.
/// </param>
/// <param name='retryPolicy'>
/// Optional. Retry Policy for Http Transient errors.
/// </param>
public HDInsightJobClient(string endpoint, BasicAuthenticationCredentials credentials, RetryPolicy retryPolicy = null)
: this(credentials)
{
if (retryPolicy == null)
{
// If No retry policy is provided then use default retry policy
retryPolicy = HDInsightJobClient.HDInsightRetryPolicy;
}
this.Endpoint = endpoint ?? throw new ArgumentNullException("endpoint");
this.Username = CultureInfo.CurrentCulture.TextInfo.ToLower(credentials.UserName);
this.SetRetryPolicy(retryPolicy);
}
public IUser GetUserForCredentials(BasicAuthenticationCredentials credentials)
{
return this.GetUserForCredentials(credentials, this.memberService);
}
