private async Task <JToken> HttpPostJsonAsync(string payload, Uri uri)
{
//var content = new StringContent(payload, Encoding.UTF8, _contentType);
var content = !DnfClient.UseCompression ? (HttpContent) new StringContent(payload, Encoding.UTF8, _contentType) : GetGZipContent(payload);
var responseMessage = await HttpClient.PostAsync(DnfClient.Proxy(uri), content)
.ConfigureAwait(false);
ParseApiUsage(responseMessage);
if (responseMessage.StatusCode == HttpStatusCode.NoContent)
{
return(string.Empty);
}
var response = await responseMessage.Content.ReadAsStreamAsync()
.ConfigureAwait(false);
using var reader = new StreamReader(response);
if (responseMessage.IsSuccessStatusCode)
{
return(DeserializeJson(reader));
}
throw new BaseHttpClientException(await reader.ReadToEndAsync()
.ConfigureAwait(false), responseMessage.StatusCode);
}
protected static async Task DeleteTestingRecords(DnfClient client)
{
(await client.Composite.DeleteAsync(
await client.QueryAsync(@"
SELECT Id FROM Case WHERE Subject LIKE 'UnitTest%'").Pull()
.Select(r => r["Id"]?.ToString()).ToListAsync()
.ConfigureAwait(false))
.ConfigureAwait(false)).Assert();
(await client.Composite.DeleteAsync(
await client.QueryAsync(@"
SELECT Id FROM Account WHERE Name LIKE 'UnitTest%'").Pull()
.Select(r => r["Id"]?.ToString()).ToListAsync()
.ConfigureAwait(false))
.ConfigureAwait(false)).Assert();
(await client.Composite.DeleteAsync(
await client.QueryAsync(@"
SELECT Id FROM Contact WHERE Name LIKE 'UnitTest%'").Pull()
.Select(r => r["Id"]?.ToString()).ToListAsync()
.ConfigureAwait(false))
.ConfigureAwait(false)).Assert();
(await client.Composite.DeleteAsync(
await client.QueryAsync(@"
SELECT Id FROM Product2 WHERE ProductCode LIKE 'UnitTest%'").Pull()
.Select(r => r["Id"]?.ToString()).ToListAsync()
.ConfigureAwait(false))
.ConfigureAwait(false)).Assert();
}
public async Task LoginFailTest()
{
await Assert.ThrowsAsync <ForceAuthException>(async() =>
{
using var client = await DnfClient.LoginAsync(new Uri("https://www.salesforce.com"), ClientId, ClientSecret, UserName, Password, WriteLine)
.ConfigureAwait(false);
});
await Assert.ThrowsAsync <ForceAuthException>(async() =>
{
using var client = await DnfClient.LoginAsync(LoginUri, "ClientId", ClientSecret, UserName, Password, WriteLine)
.ConfigureAwait(false);
});
await Assert.ThrowsAsync <ForceAuthException>(async() =>
{
using var client = await DnfClient.LoginAsync(LoginUri, ClientId, "ClientSecret", UserName, Password, WriteLine)
.ConfigureAwait(false);
});
await Assert.ThrowsAsync <ForceAuthException>(async() =>
{
using var client = await DnfClient.LoginAsync(LoginUri, ClientId, ClientSecret, "UserName", Password, WriteLine)
.ConfigureAwait(false);
});
await Assert.ThrowsAsync <ForceAuthException>(async() =>
{
using var client = await DnfClient.LoginAsync(LoginUri, ClientId, ClientSecret, UserName, "Password", WriteLine)
.ConfigureAwait(false);
});
}
protected Task <DnfClient> LoginTask()
{
var client = DnfClient.LoginAsync(
LoginUri, ClientId, ClientSecret, UserName, Password, WriteLine);
return(client);
}
public async Task <string> GenerateAsync(DnfClient client, Func <JProperty, bool> filter)
{
var objects = await RetrieveSObjectsAsync(client)
.ConfigureAwait(false);
GenerationEnvironment.Append(@"using DotNetForce;
using DotNetForce.Schema;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace ").Append(SchemaNamespace).Append(@"
{");
GenerateSchema(objects);
foreach (var prop in objects.Properties().Where(p => filter?.Invoke(p) != false))
{
// await WriteJsonAsync(prop.Name, prop.Value).ConfigureAwait(false);
GenerateObject(prop.Name, prop.Value);
}
GenerationEnvironment.Append(@"
}");
return(GenerationEnvironment.ToString());
}
public static async Task <JObject> RetrieveSObjectsAsync(DnfClient client)
{
var describeGlobalResult = await client.GetObjectsAsync()
.ConfigureAwait(false);
var request = new CompositeRequest();
if (describeGlobalResult?.SObjects != null)
{
foreach (var sObject in describeGlobalResult.SObjects)
{
var objectName = sObject["name"]?.ToString() ?? string.Empty;
if ((bool?)sObject["deprecatedAndHidden"] == true)
{
continue;
}
request.Describe(objectName, objectName);
}
}
var describeResult = await client.Composite.PostAsync(request)
.ConfigureAwait(false);
var objects = JObject.FromObject(describeResult.Results());
return(objects);
}
private static async Task RunTransformAsync()
{
var output = new StringBuilder();
var loginUrl = "";
var clientId = "";
var clientSecret = "";
var userName = "";
var password = "";
var schemaNamespace = "";
var schemaName = "";
if (loginUrl == "")
{
loginUrl = "https://test.salesforce.com";
}
if (schemaNamespace == "")
{
schemaNamespace = "DotNetForce.Schemas";
}
if (schemaName == "")
{
schemaName = "Uat";
}
try
{
loginUrl = Prompt("Login URL?", loginUrl) ?? throw new ArgumentNullException(nameof(loginUrl));
clientId = Prompt("Client Id?", clientId) ?? throw new ArgumentNullException(nameof(clientId));
clientSecret = Prompt("Client Secret?", clientSecret) ?? throw new ArgumentNullException(nameof(clientSecret));
userName = Prompt("User Name?", userName) ?? throw new ArgumentNullException(nameof(userName));
password = Prompt("Password?", password) ?? throw new ArgumentNullException(nameof(password));
schemaNamespace = Prompt("Namespace?", schemaNamespace) ?? throw new ArgumentNullException(nameof(schemaNamespace));
schemaName = Prompt("File Name?", schemaName) ?? throw new ArgumentNullException(nameof(schemaName));
var loginUri = new Uri($"{loginUrl}/services/oauth2/token");
var client = await DnfClient.LoginAsync(loginUri, clientId, clientSecret, userName, password, Console.WriteLine)
.ConfigureAwait(false);
var generator = new SchemaGenerator(output, schemaNamespace, schemaName);
await generator.GenerateAsync(client)
.ConfigureAwait(false);
}
finally
{
var filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) !, $"{schemaName}.cs");
await File.WriteAllTextAsync(filePath, output.ToString())
.ConfigureAwait(false);
}
}
public async Task <Stream> HttpGetBlobAsync(string resourceName)
{
var uri = Common.FormatUrl(resourceName, InstanceUrl, ApiVersion);
var request = new HttpRequestMessage
{
RequestUri = DnfClient.Proxy(uri),
Method = HttpMethod.Get
};
var responseMessage = await HttpClient.SendAsync(request)
.ConfigureAwait(false);
var response = await responseMessage.Content.ReadAsStreamAsync()
.ConfigureAwait(false);
return(responseMessage.IsSuccessStatusCode ? response : new MemoryStream());
}
public async Task <T?> HttpBinaryDataPostAsync <T>(string resourceName, object?inputObject, byte[] fileContents, string headerName, string fileName) where T : class
{
// BRAD: I think we should probably, in time, refactor multipart and binary support to the BaseHttpClient.
// For now though, I just left this in here.
var uri = Common.FormatUrl(resourceName, InstanceUrl, ApiVersion);
var json = JsonConvert.SerializeObject(inputObject,
Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var content = new MultipartFormDataContent();
var stringContent = new StringContent(json, Encoding.UTF8, "application/json");
stringContent.Headers.Add("Content-Disposition", "form-data; name=\"json\"");
content.Add(stringContent);
var byteArrayContent = new ByteArrayContent(fileContents);
byteArrayContent.Headers.Add("Content-Type", "application/octet-stream");
byteArrayContent.Headers.Add("Content-Disposition", $"form-data; name=\"{headerName}\"; filename=\"{fileName}\"");
content.Add(byteArrayContent, headerName, fileName);
var responseMessage = await HttpClient.PostAsync(DnfClient.Proxy(uri), content)
.ConfigureAwait(false);
var response = await responseMessage.Content.ReadAsStringAsync()
.ConfigureAwait(false);
if (responseMessage.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <T>(response));
}
throw ParseForceException(response);
}
public async Task TokenRefreshAsync(string clientId, string?refreshToken, string clientSecret, string tokenRequestEndpointUrl)
{
var url = Common.FormatRefreshTokenUrl(
tokenRequestEndpointUrl,
clientId,
refreshToken,
clientSecret);
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = DnfClient.Proxy(new Uri(url))
};
request.Headers.UserAgent.ParseAdd(string.Concat(UserAgent, "/", ApiVersion));
var responseMessage = await _httpClient.SendAsync(request)
.ConfigureAwait(false);
var response = await responseMessage.Content.ReadAsStringAsync()
.ConfigureAwait(false);
if (responseMessage.IsSuccessStatusCode)
{
var authToken = JsonConvert.DeserializeObject <AuthToken>(response);
AccessToken = authToken?.AccessToken ?? string.Empty;
RefreshToken = refreshToken;
InstanceUrl = authToken?.InstanceUrl ?? string.Empty;
Id = authToken?.Id ?? string.Empty;
}
else
{
var errorResponse = JsonConvert.DeserializeObject <AuthErrorResponse>(response);
throw new ForceException(errorResponse?.Error ?? string.Empty, errorResponse?.ErrorDescription ?? string.Empty);
}
}
private async Task <JToken> HttpGetJsonAsync(Uri uri)
{
var responseMessage = await HttpClient.GetAsync(DnfClient.Proxy(uri))
.ConfigureAwait(false);
ParseApiUsage(responseMessage);
if (responseMessage.StatusCode == HttpStatusCode.NoContent)
{
return(string.Empty);
}
var response = await responseMessage.Content.ReadAsStreamAsync()
.ConfigureAwait(false);
using var reader = new StreamReader(response);
if (responseMessage.IsSuccessStatusCode)
{
return(DeserializeJson(reader));
}
throw new BaseHttpClientException(await reader.ReadToEndAsync()
.ConfigureAwait(false), responseMessage.StatusCode);
}
public async Task UsernamePasswordAsync(string clientId, string clientSecret, string username, string password, string tokenRequestEndpointUrl)
{
if (string.IsNullOrEmpty(clientId))
{
throw new ArgumentNullException(nameof(clientId));
}
if (string.IsNullOrEmpty(clientSecret))
{
throw new ArgumentNullException(nameof(clientSecret));
}
if (string.IsNullOrEmpty(username))
{
throw new ArgumentNullException(nameof(username));
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException(nameof(password));
}
if (string.IsNullOrEmpty(tokenRequestEndpointUrl))
{
throw new ArgumentNullException(nameof(tokenRequestEndpointUrl));
}
if (!Uri.IsWellFormedUriString(tokenRequestEndpointUrl, UriKind.Absolute))
{
throw new FormatException("tokenRequestEndpointUrl");
}
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "password"),
new KeyValuePair <string, string>("client_id", clientId),
new KeyValuePair <string, string>("client_secret", clientSecret),
new KeyValuePair <string, string>("username", username),
new KeyValuePair <string, string>("password", password)
});
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = DnfClient.Proxy(new Uri(tokenRequestEndpointUrl)),
Content = content
};
request.Headers.UserAgent.ParseAdd(string.Concat(UserAgent, "/", ApiVersion));
var responseMessage = await _httpClient.SendAsync(request)
.ConfigureAwait(false);
var response = await responseMessage.Content.ReadAsStringAsync()
.ConfigureAwait(false);
if (responseMessage.IsSuccessStatusCode)
{
try {
var authToken = JsonConvert.DeserializeObject <AuthToken>(response);
AccessToken = authToken?.AccessToken ?? string.Empty;
InstanceUrl = authToken?.InstanceUrl ?? string.Empty;
Id = authToken?.Id ?? string.Empty;
}
catch (Exception ex) {
throw new ForceAuthException(ex.Message, response, responseMessage.StatusCode);
}
}
else
{
var errorResponse = JsonConvert.DeserializeObject <AuthErrorResponse>(response);
throw new ForceAuthException(errorResponse?.Error ?? string.Empty, errorResponse?.ErrorDescription ?? string.Empty, responseMessage.StatusCode);
}
}
public async Task WebServerAsync(string?clientId, string?clientSecret, string?redirectUri, string?code, string?tokenRequestEndpointUrl)
{
if (string.IsNullOrEmpty(clientId))
{
throw new ArgumentNullException(nameof(clientId));
}
// if (string.IsNullOrEmpty(clientSecret)) throw new ArgumentNullException("clientSecret");
if (string.IsNullOrEmpty(redirectUri))
{
throw new ArgumentNullException(nameof(redirectUri));
}
if (!Uri.IsWellFormedUriString(redirectUri, UriKind.Absolute))
{
throw new FormatException("redirectUri");
}
if (string.IsNullOrEmpty(code))
{
throw new ArgumentNullException(nameof(code));
}
if (string.IsNullOrEmpty(tokenRequestEndpointUrl))
{
throw new ArgumentNullException(nameof(tokenRequestEndpointUrl));
}
if (!Uri.IsWellFormedUriString(tokenRequestEndpointUrl, UriKind.Absolute))
{
throw new FormatException("tokenRequestEndpointUrl");
}
var content = string.IsNullOrEmpty(clientSecret)
? new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("client_id", clientId),
new KeyValuePair <string, string>("redirect_uri", redirectUri),
new KeyValuePair <string, string>("code", code)
})
: new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("client_id", clientId),
new KeyValuePair <string, string>("client_secret", clientSecret),
new KeyValuePair <string, string>("redirect_uri", redirectUri),
new KeyValuePair <string, string>("code", code)
});
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = DnfClient.Proxy(new Uri(tokenRequestEndpointUrl)),
Content = content
};
request.Headers.UserAgent.ParseAdd(string.Concat(UserAgent, "/", ApiVersion));
var responseMessage = await _httpClient.SendAsync(request)
.ConfigureAwait(false);
var response = await responseMessage.Content.ReadAsStringAsync()
.ConfigureAwait(false);
if (responseMessage.IsSuccessStatusCode)
{
var authToken = JsonConvert.DeserializeObject <AuthToken>(response);
AccessToken = authToken?.AccessToken;
InstanceUrl = authToken?.InstanceUrl;
Id = authToken?.Id;
RefreshToken = authToken?.RefreshToken;
}
else
{
try
{
var errorResponse = JsonConvert.DeserializeObject <AuthErrorResponse>(response);
throw new ForceAuthException(errorResponse?.Error ?? string.Empty, errorResponse?.ErrorDescription ?? string.Empty);
}
catch (Exception ex)
{
throw new ForceAuthException(Error.UnknownException, ex.Message);
}
}
}
public Task <string> GenerateAsync(DnfClient client)
{
return(GenerateAsync(client, _ => true));
}
