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