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); }