public async Task <JObject> CreateProjectAsync(string hubId, [FromBody] JObject data)
{
string accountId = hubId.Replace("b.", string.Empty);
// 2-legged account:read token
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead, Scope.AccountWrite });
Credentials credentials = await Credentials.FromSessionAsync(base.Request.Cookies, Response.Cookies);
if (!await IsAccountAdmin(hubId, bearer.access_token, credentials))
{
return(null);
}
RestClient client = new RestClient(BASE_URL);
RestRequest requestCreateProject = new RestRequest("/hq/v1/accounts/{account_id}/projects", RestSharp.Method.POST);
requestCreateProject.AddParameter("account_id", accountId, ParameterType.UrlSegment);
requestCreateProject.AddParameter("application/json", Newtonsoft.Json.JsonConvert.SerializeObject(data), ParameterType.RequestBody);
requestCreateProject.AddHeader("Authorization", "Bearer " + bearer.access_token);
IRestResponse response = await client.ExecuteTaskAsync(requestCreateProject);
return(JObject.Parse(response.Content));
}
public async Task <string> GetContainerIdAsync(string hubId, string projectId)
{
var containerId = string.Empty;
var oauth = new TwoLeggedApi();
var bearer = await oauth.AuthenticateAsync(ForgeClientId, ForgeClientSecret, "client_credentials", new[] { Scope.DataRead });
var client = new RestClient(BaseUrl);
var request = new RestRequest("project/v1/hubs/{hub_id}/projects", Method.GET);
request.AddHeader("Authorization", "Bearer " + Credentials.TokenInternal);
request.AddParameter("hub_id", hubId, ParameterType.UrlSegment);
request.AddParameter("page[limit]", 99, ParameterType.QueryString);
var response = await client.ExecuteAsync(request);
dynamic projects = JObject.Parse(response.Content);
foreach (var project in projects.data)
{
if (project.id.ToString() == projectId)
{
containerId = project.relationships.issues.data.id.ToString();
}
}
return(containerId);
}
private async void btnAuthenticate_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(txtClientId.Text) || string.IsNullOrWhiteSpace(txtClientSecret.Text))
{
return;
}
// get the access token
TwoLeggedApi oAuth = new TwoLeggedApi();
Bearer token = (await oAuth.AuthenticateAsync(
txtClientId.Text,
txtClientSecret.Text,
oAuthConstants.CLIENT_CREDENTIALS,
new Scope[] { Scope.BucketRead, Scope.BucketCreate, Scope.DataRead, Scope.DataWrite })).ToObject <Bearer>();
txtAccessToken.Text = token.AccessToken;
_expiresAt = DateTime.Now.AddSeconds(token.ExpiresIn.Value);
// keep track on time
_tokenTimer.Tick += new EventHandler(tickTokenTimer);
_tokenTimer.Interval = 1000;
_tokenTimer.Enabled = true;
btnRefreshToken_Click(null, null);
}
public async Task <JArray> GetProjectByUser(string hubId)
{
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead, Scope.DataRead });
JArray users = await GetUsers(hubId, bearer.access_token);
foreach (dynamic user in users)
{
user.projects = new JArray();
user.projects_count = 0;
if (user.uid == null)
{
continue; // not activated yet
}
dynamic projects = await GetProjectsAsync(hubId, (string)user.uid, (string)bearer.access_token);
if (projects == null)
{
continue;
}
foreach (dynamic project in projects.data)
{
dynamic projectInfo = new JObject();
projectInfo.name = project.attributes.name;
projectInfo.id = project.id;
user.projects.Add(projectInfo);
}
user.projects_count = ((JArray)user.projects).Count;
}
return(new JArray(users.OrderByDescending(u => (int)u["projects_count"])));
}
private async Task <bool> IsAccountAdmin(string hubId, Credentials credentials)
{
UserProfileApi userApi = new UserProfileApi();
userApi.Configuration.AccessToken = credentials.TokenInternal;
dynamic profile = await userApi.GetUserProfileAsync();
// 2-legged account:read token
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Config.GetAppSetting("FORGE_CLIENT_ID"), Config.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead });
RestClient client = new RestClient(Config.BaseUrl);
RestRequest thisUserRequest = new RestRequest("/hq/v1/accounts/{account_id}/users/search?email={email}&limit=1", RestSharp.Method.GET);
thisUserRequest.AddParameter("account_id", hubId.Replace("b.", string.Empty), ParameterType.UrlSegment);
thisUserRequest.AddParameter("email", profile.emailId, ParameterType.UrlSegment);
thisUserRequest.AddHeader("Authorization", "Bearer " + bearer.access_token);
IRestResponse thisUserResponse = await client.ExecuteTaskAsync(thisUserRequest);
dynamic thisUser = JArray.Parse(thisUserResponse.Content);
string role = thisUser[0].role;
return(role == "account_admin");
}
private async Task <Auth> GetAccessToken(Scope[] scopes)
{
Auth cachedAuth;
var cacheKey = string.Join("+", from scope in scopes select scope.ToString());
if (!authCache.TryGetValue(cacheKey, out cachedAuth) || cachedAuth.ExpiresAt >= DateTime.Now)
{
var client = new TwoLeggedApi();
var response = await client.AuthenticateAsync(clientId, clientSecret, "client_credentials", scopes);
cachedAuth = new Auth
{
AccessToken = response.access_token,
ExpiresIn = response.expires_in,
ExpiresAt = DateTime.Now.AddSeconds(response.expires_in)
};
if (authCache.ContainsKey(cacheKey))
{
authCache.Remove(cacheKey);
}
authCache.Add(cacheKey, cachedAuth);
}
return(new Auth
{
AccessToken = cachedAuth.AccessToken,
ExpiresAt = cachedAuth.ExpiresAt,
ExpiresIn = (long)cachedAuth.ExpiresAt.Subtract(DateTime.Now).TotalSeconds
});
}
/// <summary>
/// Perform the OAuth authorization via code
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public static async Task <Credentials> CreateFromCodeAsync(string code, IResponseCookies cookies)
{
ThreeLeggedApi oauth = new ThreeLeggedApi();
TwoLeggedApi da4rOauth = new TwoLeggedApi(); // added for DA4R
dynamic credentialInternal = await oauth.GettokenAsync(
GetAppSetting("FORGE_CLIENT_ID"), GetAppSetting("FORGE_CLIENT_SECRET"),
oAuthConstants.AUTHORIZATION_CODE, code, GetAppSetting("FORGE_CALLBACK_URL"));
dynamic credentialPublic = await oauth.RefreshtokenAsync(
GetAppSetting("FORGE_CLIENT_ID"), GetAppSetting("FORGE_CLIENT_SECRET"),
"refresh_token", credentialInternal.refresh_token, new Scope[] { Scope.ViewablesRead });
// added for DA4R
dynamic credentialDa4rInternal = await da4rOauth.AuthenticateAsync(
GetAppSetting("FORGE_CLIENT_ID"), GetAppSetting("FORGE_CLIENT_SECRET"),
"client_credentials", new Scope[] { Scope.BucketCreate, Scope.BucketRead, Scope.BucketUpdate, Scope.DataRead, Scope.DataWrite, Scope.DataCreate, Scope.CodeAll });
Credentials credentials = new Credentials();
credentials.TokenInternal = credentialInternal.access_token;
credentials.DA4RTokenInternal = credentialDa4rInternal.access_token; //added for DA4R
credentials.TokenPublic = credentialPublic.access_token;
credentials.RefreshToken = credentialPublic.refresh_token;
credentials.ExpiresAt = DateTime.Now.AddSeconds(credentialInternal.expires_in);
cookies.Append(FORGE_COOKIE, JsonConvert.SerializeObject(credentials));
return(credentials);
}
public static async Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi apiInstance = new TwoLeggedApi();
string grantType = "client_credentials";
dynamic bearer = await apiInstance.AuthenticateAsync(Config.FORGE_CLIENT_ID, Config.FORGE_CLIENT_SECRET, grantType, scopes);
return(bearer);
}
private async Task <JObject> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
dynamic bearer = await oauth.AuthenticateAsync(ClientId, ClientSecret, grantType, scopes);
return(JObject.FromObject(bearer));
}
private static async Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_cridentials";
dynamic bearer = await oauth.AuthenticateAsync(GetAppSetting(clientId), GetAppSetting(secret), grantType, scopes);
return(bearer);
}
public static async Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi apiInstance = new TwoLeggedApi();
string grantType = "client_credentials";
dynamic bearer = await apiInstance.AuthenticateAsync("BmNe4PXIAdDC3DfrWqX4jaaKcUVLHzGs", "FvjXbdJbWzQUjkL0", grantType, scopes);
return(bearer);
}
public async Task <bool> GetIsAccountAdmin(string hubId)
{
Credentials credentials = await Credentials.FromSessionAsync(base.Request.Cookies, Response.Cookies);
// 2-legged account:read token
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead });
return(await IsAccountAdmin(hubId, bearer.access_token, credentials));
}
/// <summary>
/// Get the access token from Autodesk
/// </summary>
private static async Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
string clientId = GetAppSetting("FORGE_CLIENT_ID");
string clientSecret = GetAppSetting("FORGE_CLIENT_SECRET");
dynamic bearer = await oauth.AuthenticateAsync(clientId, clientSecret, grantType, scopes);
return(bearer);
}
/// <summary>
/// Get the access token from Autodesk.
/// </summary>
/// <param name="scopes">The scopes<see cref="Scope[]"/>.</param>
/// <returns>The <see cref="Task{dynamic}"/>.</returns>
public async Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
dynamic bearer = await oauth.AuthenticateAsync(config.ClientId,
config.ClientSecret,
grantType,
scopes);
return(bearer);
}
public async Task <string> GetToken()
{
TwoLeggedApi oauthApi = new TwoLeggedApi();
dynamic bearer = await oauthApi.AuthenticateAsync(
"mUAnGJsDnZAALOTZdNGDcV68ReVuscXO",
"coCCQ99xevcPpLjD",
"client_credentials",
new Scope[] { Scope.DataRead });
return((string)bearer.access_token);
}
// Initialize the 2-legged OAuth 2.0 client, and optionally set specific scopes.
private static void initializeOAuth()
{
// You must provide at least one valid scope
Scope[] scopes = new Scope[] { Scope.DataRead, Scope.DataWrite, Scope.BucketCreate, Scope.BucketRead };
// TLS enforce due to https://forge.autodesk.com/ja/node/1098
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
oauth2TwoLegged = new TwoLeggedApi();
twoLeggedCredentials = oauth2TwoLegged.AuthenticateAsync(FORGE_CLIENT_ID, FORGE_CLIENT_SECRET, oAuthConstants.CLIENT_CREDENTIALS, scopes).Result;
objectsApi.Configuration.AccessToken = twoLeggedCredentials.access_token;
}
/// <summary>
/// Get the access token from Autodesk
/// </summary>
private static async Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
dynamic bearer = await oauth.AuthenticateAsync(
Environment.GetEnvironmentVariable("FORGE_CLIENT_ID"),
Environment.GetEnvironmentVariable("FORGE_CLIENT_SECRET"),
grantType,
scopes);
return(bearer);
}
/// <summary>
/// Fetches the token based on the scope argument
/// </summary>
/// <returns>token</returns>
private async static Task <dynamic> Get2LeggedTokenAsync(Scope[] scopes)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
dynamic bearer = await oauth.AuthenticateAsync(
ConsumerKey,
ConsumerSecret,
grantType,
scopes);
return(bearer);
}
private async Task <IRestResponse> GetProjectUsers(string accountId, string projectId, Nullable <int> pageOffset = null, Nullable <int> pageLimit = null)
{
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead });
RestClient client = new RestClient(BASE_URL);
RestRequest request = new RestRequest("/bim360/admin/v1/projects/{project_id}/users", RestSharp.Method.GET);
request.AddParameter("project_id", projectId.Replace("b.", string.Empty), ParameterType.UrlSegment);
request.AddHeader("Authorization", "Bearer " + bearer.access_token);
return(await client.ExecuteTaskAsync(request));
}
public static async Task <IRestResponse> GetUsersAsync(string accountId, Region region)
{
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead, Scope.DataRead });
RestClient client = new RestClient(BASE_URL);
RestRequest request = new RestRequest("/hq/v1/" + region.Resource + "/{account_id}/users?limit=100", RestSharp.Method.GET);
request.AddParameter("account_id", accountId.Replace("b.", string.Empty), ParameterType.UrlSegment);
request.AddHeader("Authorization", "Bearer " + bearer.access_token);
return(await client.ExecuteTaskAsync(request));
}
public async Task <HttpResponseMessage> GetToken()
{
TwoLeggedApi oauthApi = new TwoLeggedApi();
dynamic bearer = await oauthApi.AuthenticateAsync(WebConfigurationManager.AppSettings["FORGE_CLIENT_ID"],
WebConfigurationManager.AppSettings["FORGE_CLIENT_SECRET"],
"client_credentials", new Scope[] { Scope.DataRead }
);
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent(bearer.access_token, System.Text.Encoding.UTF8, "text/plain");
return(response);
}
public static async Task <string> GetAccessToken(string clientId, string clientSecret)
{
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic reply = await oauth.AuthenticateAsync(
clientId,
clientSecret,
oAuthConstants.CLIENT_CREDENTIALS,
new Scope[] { Scope.CodeAll });
string accessToken = reply.access_token;
Console.WriteLine(accessToken);
return(accessToken);
}
public async Task <JArray> GetQualityIssuesAsync(string hubId, string projectId)
{
Credentials = await Credentials.FromSessionAsync(base.Request.Cookies, Response.Cookies);
if (Credentials == null)
{
return(null);
}
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead });
JArray users = await GetUsers(hubId, bearer.access_token);
JArray issues = new JArray();
dynamic response = null;
int offset = 0;
do
{
response = await GetResourceAsync(await GetContainerAsync(hubId, projectId), "quality-issues", offset);
issues.Merge(response.data);
offset += 50;
} while (!string.IsNullOrEmpty((string)response.links.next));
foreach (dynamic issue in issues)
{
if (issue.attributes.created_by != null)
{
issue.attributes.owner = GetUserById(users, (string)issue.attributes.owner);
}
if (issue.attributes.created_by != null)
{
issue.attributes.created_by = GetUserById(users, (string)issue.attributes.created_by);
}
if (issue.attributes.created_by != null)
{
issue.attributes.assigned_to = GetUserById(users, (string)issue.attributes.assigned_to);
}
if (issue.attributes.created_by != null)
{
issue.attributes.answered_by = GetUserById(users, (string)issue.attributes.answered_by);
}
}
return(issues);
}
public async Task <string> CreateBIM360Project([FromBody] Project newProject)
{
TwoLeggedApi twoLeggedApi = new TwoLeggedApi();
dynamic bearer = await twoLeggedApi.AuthenticateAsync(ConfigVariables.FORGE_CLIENT_ID, ConfigVariables.FORGE_CLIENT_SECRET, "client_credentials", new Scope[] { Scope.AccountWrite });
string body = JsonConvert.SerializeObject(newProject);
RestClient client = new RestClient("https://developer.api.autodesk.com");
RestRequest request = new RestRequest("/hq/v1/accounts/{account_id}/projects", Method.POST);
request.AddParameter("account_id", newProject.HubId, ParameterType.UrlSegment);
request.AddHeader("Authorization", "Bearer " + bearer.access_token);
request.AddParameter("application/json", body, ParameterType.RequestBody);
IRestResponse response = await client.ExecuteTaskAsync(request);
return(response.Content); // ToDo
}
/// <summary>
/// Get access token async.
/// </summary>
/// <returns>Access token</returns>
public async Task <Token> GetTokenAsync()
{
var response = await api.AuthenticateAsync(clientID, clientSecret,
grantType : "client_credentials", scopes);
if (string.IsNullOrEmpty(response.ToString()))
{
return(null);
}
Dictionary <string, dynamic> json = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(response.ToString());
Token token = new Token(json["token_type"],
(int)json["expires_in"],
json["access_token"]);
return(token);
}
public static async Task <dynamic> GetInternalAsync()
{
if (InternalToken == null)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
string forgeId = WebConfigurationManager.AppSettings["FORGE_CLIENT_ID"];
string forgeClient = WebConfigurationManager.AppSettings["FORGE_CLIENT_SECRET"];
InternalToken = await oauth.AuthenticateAsync(
forgeId,
forgeClient,
grantType,
new Scope[] { Scope.BucketCreate, Scope.BucketRead, Scope.DataRead, Scope.DataCreate, Scope.DataWrite });
}
return(InternalToken);
}
public async Task <dynamic> GetPublicAsync()
{
if (PublicToken == null)
{
TwoLeggedApi oauth = new TwoLeggedApi();
string grantType = "client_credentials";
string forgeId = WebConfigurationManager.AppSettings["FORGE_CLIENT_ID"];
string forgeClient = WebConfigurationManager.AppSettings["FORGE_CLIENT_SECRET"];
PublicToken = await oauth.AuthenticateAsync(
forgeId,
forgeClient,
grantType,
new Scope[] { Scope.ViewablesRead });
}
return(PublicToken);
}
public async Task <IActionResult> ImportUsersAsync(string accountId, string projectId, [FromBody] JObject data)
{
Credentials credentials = await Credentials.FromSessionAsync(base.Request.Cookies, Response.Cookies);
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic bearer = await oauth.AuthenticateAsync(Credentials.GetAppSetting("FORGE_CLIENT_ID"), Credentials.GetAppSetting("FORGE_CLIENT_SECRET"), "client_credentials", new Scope[] { Scope.AccountRead, Scope.AccountWrite });
if (!await IsAccountAdmin(accountId, bearer.access_token, credentials))
{
return(null);
}
string roleId = data["roleId"].Value <string>();
JArray users = data["userIds"].Value <JArray>();
dynamic usersToAdd = new JArray();
foreach (dynamic user in users)
{
dynamic userToAdd = new JObject();
userToAdd.user_id = user;
userToAdd.industry_roles = new JArray();
userToAdd.industry_roles.Add(roleId);
userToAdd.services = new JObject();
userToAdd.services.project_administration = new JObject();
userToAdd.services.project_administration.access_level = "admin";
userToAdd.services.document_management = new JObject();
userToAdd.services.document_management.access_level = "admin";
usersToAdd.Add(userToAdd);
}
RestClient client = new RestClient(BASE_URL);
RestRequest importUserRequest = new RestRequest("/hq/v2/accounts/{account_id}/projects/{project_id}/users/import", RestSharp.Method.POST);
importUserRequest.AddParameter("account_id", accountId.Replace("b.", string.Empty), ParameterType.UrlSegment);
importUserRequest.AddParameter("project_id", projectId.Replace("b.", string.Empty), ParameterType.UrlSegment);
importUserRequest.AddParameter("application/json", Newtonsoft.Json.JsonConvert.SerializeObject(usersToAdd), ParameterType.RequestBody);
importUserRequest.AddHeader("Authorization", "Bearer " + credentials.TokenInternal);
IRestResponse importUserResponse = await client.ExecuteTaskAsync(importUserRequest);
return(Ok());
}
public async Task <List <Project> > GetProjectsAsync(Credentials credentials, string hubId)
{
var projectsList = new List <Project>();
var oauth = new TwoLeggedApi();
var bearer = await oauth.AuthenticateAsync(ForgeClientId, ForgeClientSecret, "client_credentials", new[] { Scope.DataRead });
var client = new RestClient(BaseUrl);
var request = new RestRequest("project/v1/hubs/{hub_id}/projects", Method.GET);
request.AddHeader("Authorization", "Bearer " + credentials.TokenInternal);
request.AddParameter("hub_id", hubId, ParameterType.UrlSegment);
request.AddParameter("page[limit]", 99, ParameterType.QueryString);
var response = await client.ExecuteAsync(request);
dynamic projects = JObject.Parse(response.Content);
// List<string> projectsForIssueTransfer = JsonConvert.DeserializeObject<List<string>>(System.IO.File.ReadAllText(Path.Combine(
// Directory.GetCurrentDirectory(), "projects.json"), Encoding.GetEncoding(1251)));
var projectsFromFile = File.ReadAllText("projects.json");
var projectsJson = JsonConvert.DeserializeObject <List <ProjInfo> >(projectsFromFile);
foreach (var project in projects.data)
{
var projectWithSameName = projectsJson.FirstOrDefault(x => x.Project == project.attributes.name.ToString());
if (projectWithSameName != null)
{
var pr = new Project
{
ProjectBim360Id = project.id.ToString(),
Title = project.attributes.name.ToString()
};
projectsList.Add(pr);
}
}
return(projectsList);
}
static async Task <string> GetAccessToken(CommandOption clientIdParam, CommandOption clientSecretParam)
{
string clientId = null, clientSecret = null;
try {
clientId = Environment.GetEnvironmentVariable("FORGE_CLIENT_ID");
clientSecret = Environment.GetEnvironmentVariable("FORGE_CLIENT_SECRET");
} catch { }
if (clientIdParam.HasValue())
{
clientId = clientIdParam.Value();
}
if (clientSecretParam.HasValue())
{
clientSecret = clientSecretParam.Value();
}
if (clientId == null || clientSecret == null)
{
Console.WriteLine("FORGE_CLIENT_ID and/or FORGE_CLIENT_SECRET not defined either as environment variables or command options -ci/-cs.");
return(null);
}
TwoLeggedApi oauth = new TwoLeggedApi();
dynamic reply = await oauth.AuthenticateAsync(
clientId,
clientSecret,
oAuthConstants.CLIENT_CREDENTIALS,
new Scope[] { Scope.CodeAll });
string accessToken = reply.access_token;
Console.WriteLine(accessToken);
return(accessToken);
}
