internal static User GetWhoAmI(IEnumerable <FluxCookie> cookies, SDKMetadata sdkMetadata) { if (cookies == null) { return(null); } var authCookie = cookies.FirstOrDefault(el => el.CookieName == FluxApiData.CookiesAuthName); if (authCookie == null) { return(null); } User user = null; var request = HttpWebClientHelper.CreateRequest(sdkMetadata, FluxApiData.WhoAmIUrl, cookies.ToList()); request.Method = "GET"; using (var response = HttpWebClientHelper.GetResponse(request)) { user = DataSerializer.Deserialize <User>(StreamUtils.GetDecompressedResponseStream(response)); } user.SdkMetadata = sdkMetadata; user.Cookies = cookies.ToList(); return(user); }
/// <summary>Obtain plugin versions supported by Flux</summary> /// <returns>List of products and versions currently supported by Flux.</returns> /// <exception cref="Exceptions.FluxException">Throws for internal SDK exceptions (Network is down, etc.).</exception> /// <exception cref="Exceptions.ConnectionFailureException">Throws if network connection is down.</exception> /// <exception cref="Exceptions.ServerUnavailableException">Throws if Flux server is down.</exception> /// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception> public PluginVersions GetSupportedVersions() { log.Info("Getting Supported Versions data"); var request = HttpWebClientHelper.CreateRequest(sdkMetadata, FluxApiData.EnvUrl, null); request.Method = "GET"; try { using (var response = HttpWebClientHelper.GetResponse(request)) { return(DataSerializer.Deserialize <PluginVersions>(StreamUtils.GetDecompressedResponseStream(response))); } } catch (Exceptions.FluxException ex) { log.Error(ex); throw; } catch (Exception ex) { log.Error(ex); throw new Exceptions.InternalSDKException(ex.Message); } }
/// <summary>Update list of projects for the current user. </summary> /// <exception cref="Exceptions.ConnectionFailureException">Throws if network connection is down.</exception> /// <exception cref="Exceptions.UnathorizedException">Throws if provided cookies were obsolete.</exception> /// <exception cref="Exceptions.ServerUnavailableException">Throws if Flux server is down.</exception> /// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception> public void UpdateProjects() { var projectList = new List <Project>(); var request = HttpWebClientHelper.CreateRequest(SdkMetadata, FluxApiData.ProjectsUrl, Cookies); request.Method = "GET"; request.Headers.Add("user", Id); try { using (var response = HttpWebClientHelper.GetResponse(request)) { projectList = DataSerializer.Deserialize <List <Project> >(StreamUtils.GetDecompressedResponseStream(response)); } } catch (Exceptions.FluxException ex) { log.Error(ex); throw; } catch (Exception ex) { log.Error(ex); throw new Exceptions.InternalSDKException(ex.Message); } Projects = projectList; }
/// <summary>Delete project by id.</summary> /// <param name="projectId">Id of the project to be deleted.</param> /// <returns>true if project was deleted successfully.</returns> /// <exception cref="Exceptions.ConnectionFailureException">Throws if network connection is down.</exception> /// <exception cref="Exceptions.UnathorizedException">Throws if provided cookies were obsolete.</exception> /// <exception cref="Exceptions.ForbiddenException">Throws if user doesn't have rights to delete this project.</exception> /// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception> public async Task <bool> DeleteProjectAsync(string projectId) { var request = HttpWebClientHelper.CreateRequest(SdkMetadata, string.Format(FluxApiData.ProjectDeleteUrl, projectId), Cookies); request.Method = "DELETE"; try { using (var response = await HttpWebClientHelper.GetResponseAsync(request)) { if (response != null) { var project = Projects.FirstOrDefault(x => x.Id == projectId); if (projects != null && project != null) { project.Cookies = null; projects.Remove(project); } return(true); } } } catch (Exceptions.FluxException ex) { log.Error(ex); throw; } catch (Exception ex) { log.Error(ex); throw new Exceptions.InternalSDKException(ex.Message); } return(false); }
/// <summary>Convert brep to specified format.</summary> /// <param name="content">Brep to convert (base64 encoded string).</param> /// <param name="sourceFormat">Source format of brep.</param> /// <param name="targetFormat">Target format of brep</param> /// <returns>Converted brep (base64 encoded string).</returns> /// <exception cref="Exceptions.ConnectionFailureException">Throws if network connection is down.</exception> /// <exception cref="Exceptions.UnathorizedException">Throws if provided cookies were obsolete.</exception> /// <exception cref="Exceptions.ServerUnavailableException">Throws if Flux server is down.</exception> /// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception> public string ConvertBrep(string content, string sourceFormat, string targetFormat) { if (string.IsNullOrEmpty(content)) { return(null); } #region Create object wrapper for brep var brep = new BrepToConvert.SceneObject.BrepPrimitive(); brep.Primitive = "brep"; brep.Format = sourceFormat; brep.Content = content; var entities = new BrepToConvert.SceneObject.EntitiesObject(); entities.Brep = brep; BrepToConvert.SceneObject scene = new BrepToConvert.SceneObject(); scene.Entities = entities; var initObj = new BrepToConvert.SceneObject.OperationObj(); initObj.Name = "result"; initObj.Op = new string[] { "repr", targetFormat, "brep@1" }; scene.Operations = new object[] { initObj }; var brepToConvert = new BrepToConvert(); brepToConvert.Scene = scene; #endregion var request = WriteBrepToRequest(brepToConvert); try { using (var response = HttpWebClientHelper.GetResponse(request)) { dynamic responseJson = DataSerializer.DynamicDeserialize(StreamUtils.GetDecompressedResponseStream(response)); dynamic convertedContent = responseJson.Output.Results.value.result.content; if (convertedContent != null) { object contentStr = convertedContent; return(contentStr.ToString()); } } } catch (Exceptions.FluxException ex) { log.Error(ex); throw; } catch (Exception ex) { log.Error(ex); throw new Exceptions.InternalSDKException(ex.Message); } return(null); }
private HttpWebRequest WriteBrepToRequest(BrepToConvert brep) { var request = HttpWebClientHelper.CreateRequest(SdkMetadata, string.Format(FluxApiData.ConvertUrl, Id), Cookies); request.Method = "POST"; var jsonStr = DataSerializer.Serialize(brep); byte[] bytes = Encoding.UTF8.GetBytes(jsonStr); request.ContentLength = bytes.Length; using (Stream stream = request.GetRequestStream()) { stream.Write(bytes, 0, bytes.Length); } return(request); }
/// <summary>Create new project.</summary> /// <param name="projectName">name of the new project.</param> /// <returns>Porject instance if project was created successully.</returns> /// <exception cref="Exceptions.FluxException">Throws for internal SDK exceptions (Network is down, etc.).</exception> /// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception> public async Task <Project> CreateNewProjectAsync(string projectName) { Project newProject = null; var request = HttpWebClientHelper.CreateRequest(SdkMetadata, FluxApiData.ProjectsUrl, Cookies); request.Method = "POST"; try { string formParams = string.Format("user={0}&name={1}&app={2}", Uri.EscapeDataString(Id), Uri.EscapeDataString(projectName), Uri.EscapeDataString("blank")); byte[] bytes = Encoding.ASCII.GetBytes(formParams); request.ContentLength = bytes.Length; using (Stream stream = request.GetRequestStream()) { stream.Write(bytes, 0, bytes.Length); } using (var response = await HttpWebClientHelper.GetResponseAsync(request)) { newProject = DataSerializer.Deserialize <Project>(StreamUtils.GetDecompressedResponseStream(response)); if (newProject != null) { newProject.Cookies = Cookies; newProject.SdkMetadata = SdkMetadata; } if (projects != null) { projects.Add(newProject); } } } catch (Exceptions.FluxException ex) { log.Error(ex); throw; } catch (Exception ex) { log.Error(ex); throw new Exceptions.InternalSDKException(ex.Message); } return(newProject); }
internal void ObtainToken(Uri uri) { try { var code = HttpUtility.ParseQueryString(uri.Query).Get("code"); var fluxToken = HttpUtility.ParseQueryString(uri.Query).Get("flux_token"); var returnedStateId = HttpUtility.ParseQueryString(uri.Query).Get("state"); //we MUST verify state if (string.IsNullOrEmpty(returnedStateId) || returnedStateId != stateId.ToString()) { throw new Exceptions.AuthorizationFailedException("State uuids don't match."); } //requesting access_token var request = HttpWebClientHelper.CreateRequest(sdkMetadata, FluxApiData.TokenUrl, null); request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded"; var authStr = sdkMetadata.ClientInfo.ClientId + ":" + clientSecret; var authStrBytes = Encoding.UTF8.GetBytes(authStr); request.Headers["Authorization"] = "Basic " + Convert.ToBase64String(authStrBytes); string formParams = string.Format("client_id={0}&code={1}&grant_type=authorization_code&redirect_uri={2}", Uri.EscapeDataString(sdkMetadata.ClientInfo.ClientId), Uri.EscapeDataString(code), Uri.EscapeUriString(RedirectUrl)); byte[] bytes = Encoding.ASCII.GetBytes(formParams); request.ContentLength = bytes.Length; using (Stream stream = request.GetRequestStream()) { stream.Write(bytes, 0, bytes.Length); } using (var response = HttpWebClientHelper.GetResponse(request)) { var token = DataSerializer.Deserialize <Token>(StreamUtils.GetDecompressedResponseStream(response)); if (token != null && !string.IsNullOrEmpty(token.AccessToken) && !string.IsNullOrEmpty(fluxToken) && !string.IsNullOrEmpty(token.IdToken)) { //verify nonce uuid JwtSecurityToken jwtSecurityToken = new JwtSecurityToken(token.IdToken); var returnedNonceId = jwtSecurityToken.Payload.Nonce; if (string.IsNullOrEmpty(returnedNonceId) || returnedNonceId != nonceId.ToString()) { throw new Exceptions.AuthorizationFailedException("Nonce uuids don't match."); } token.FluxToken = fluxToken; Init(token); var path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"Flux\fluxData.bin"); if (!string.IsNullOrEmpty(AccessToken) && !string.IsNullOrEmpty(FluxToken)) { var cookies = new List <FluxCookie>(); var authCook = new FluxCookie() { CookieName = "auth", CookieValue = Uri.UnescapeDataString(AccessToken), CookieDomain = sdkMetadata.BaseUri.Host }; cookies.Add(authCook); var fluxCook = new FluxCookie() { CookieName = "flux_token", CookieValue = Uri.UnescapeDataString(FluxToken), CookieDomain = sdkMetadata.BaseUri.Host }; cookies.Add(fluxCook); Utils.StoreOICCookies(path, cookies, sdkMetadata.ClientInfo.ClientId); } } else { log.Debug("Unable to receive token."); throw new Exceptions.AuthorizationFailedException( "Authentication has been failed. See log for more details."); } } } catch (Exceptions.AuthorizationFailedException) { throw; } catch (Exception ex) { log.Error(ex); throw new Exceptions.AuthorizationFailedException(ex.Message); } }
private void Reconnect() { log.Debug("Trying to reconnect websocket."); if (isConnecting) { return; } Stop(); //close current connection log.Debug("Trying to close old connection."); Close(); isConnecting = true; log.Debug("Start getting request to obtain ws address."); var request = HttpWebClientHelper.CreateRequest(sdkMetadata, string.Format(FluxApiData.WebSocketUrl, ProjectId, reason), UserCookies); request.Method = "GET"; request.Headers.Add("projectId", ProjectId); try { var response = HttpWebClientHelper.GetResponse(request); if (response.StatusCode == HttpStatusCode.OK) { var wsUrl = DataSerializer.Deserialize <WebSocketAddress>(StreamUtils.GetDecompressedResponseStream(response)); log.Debug("Connecting to Flux wss: {0}", wsUrl.Address); webSocket = new WebSocketSharp.WebSocket(wsUrl.Address); webSocket.WaitTime = TimeSpan.FromHours(12); foreach (var cookie in UserCookies) { WebSocketSharp.Net.Cookie wsCookie = new WebSocketSharp.Net.Cookie(cookie.CookieName, cookie.CookieValue, cookie.CookieDomain); webSocket.SetCookie(wsCookie); } webSocket.OnMessage += WebSocket_OnMessage; webSocket.OnClose += WebSocket_Closed; webSocket.OnOpen += WebSocket_Opened; webSocket.OnError += WebSocket_OnError; webSocket.ConnectAsync(); //start timer RestartConnectionTimer(); } } catch (Exception ex) { log.Error(ex); webSocketState = FluxWebSocketStates.Reconnecting; if (ex is WebException || ex is Exceptions.ConnectionFailureException || ex is Exceptions.ServerUnavailableException) { var webException = ex as WebException; if (webException != null) { var webResponse = (HttpWebResponse)webException.Response; if (webResponse != null) { Close(); return; } } log.Error("Error initializing WebSocket."); isConnecting = false; if (reconnectDelay * 2 < MAX_DELAY) { reconnectDelay *= 2; } else { reconnectDelay = MAX_DELAY; } RetryReconnect(); } else { log.Error("Unsupported exception was caught. Websocket will be closed."); Close(); } } }