/// <summary>
/// Exposed method for users to call when trying to download the meta data of the Streams the current
/// logged in user is able to access. Use this to get the IDs of the streams you would later want to start
/// receiving or use the rest of the data to populate your UI with data describing the Streams that are
/// available.
/// </summary>
/// <param name="callBack">A method callback which takes a <c>SpeckleStream</c> array.</param>
/// <returns>An async Task which can be awaited with a coroutine or just ignored.</returns>
/// <remarks>If download was successful, the resulting array is passed back. If failed, null
/// is passed. Need to be using the <c>SpeckleCore</c> namespace to access this type.</remarks>
public virtual async Task GetAllStreamMetaDataForUserAsync(Action <SpeckleStream[]> callBack)
{
if (loggedInUser == null)
{
throw new UnauthorizedAccessException("Need to be logged in before getting stream meta data.");
}
SpeckleApiClient userStreamsClient = new SpeckleApiClient(serverUrl.Trim());
userStreamsClient.AuthToken = loggedInUser.Apitoken;
ResponseStream streamsGet = await userStreamsClient.StreamsGetAllAsync(null);
if (streamsGet == null)
{
Debug.LogError("Could not get streams for user");
callBack?.Invoke(null);
}
else
{
List <SpeckleStream> streams = streamsGet.Resources;
Debug.Log("Got " + streams.Count + " streams for user");
callBack?.Invoke(streams.ToArray());
}
}
private void AddAccountFromRedirect(string redirect)
{
var myString = Uri.UnescapeDataString(redirect);
var splitRes = myString.Replace("?token=", "").Split(new[] { ":::" }, StringSplitOptions.None);
var token = splitRes[0];
//var serverUrl = splitRes[1];
var apiCl = new SpeckleApiClient(_apiUri)
{
AuthToken = token
};
var res = apiCl.UserGetAsync().Result;
var apiToken = res.Resource.Apitoken;
var email = res.Resource.Email;
SaveOrUpdateAccount(new Account()
{
RestApi = apiCl.BaseUrl, Email = email, Token = apiToken
});
Dispatcher.Invoke(() =>
{
//defaultServer = "";
showSigninsuccess = true;
isInRequestFlow = false;
LoadAccounts();
});
}
/// <summary>
/// Exposed method for users to call when trying to download the meta data of the Projects the current
/// logged in user is able to access.
/// </summary>
/// <param name="callBack">A method callback which takes a <c>Project</c> array.</param>
/// <returns>An async Task which can be awaited with a coroutine or just ignored.</returns>
/// <remarks>If download was successful, the resulting array is passed back. If failed, null
/// is passed. Need to be using the <c>SpeckleCore</c> namespace to access this type.</remarks>
public virtual async Task GetAllProjectMetaDataForUserAsync(Action <Project[]> callBack)
{
if (loggedInUser == null)
{
throw new UnauthorizedAccessException("Need to be logged in before getting project data.");
}
SpeckleApiClient userProjectsClient = new SpeckleApiClient(serverUrl.Trim());
userProjectsClient.AuthToken = loggedInUser.Apitoken;
ResponseProject projectsGet = await userProjectsClient.ProjectGetAllAsync();
if (projectsGet == null)
{
Debug.LogError("Could not get projects for user");
callBack?.Invoke(null);
}
else
{
List <Project> projects = projectsGet.Resources;
Debug.Log("Got " + projects.Count + " projects for user");
callBack?.Invoke(projects.ToArray());
}
}
static async void MainAsync(string[] args)
{
Console.WriteLine("Done.");
Console.WriteLine();
Console.WriteLine("Setting up client.");
SpeckleApiClient myClient = new SpeckleApiClient();
myClient.BaseUrl = "http://10.211.55.2:3000/api/v1";
var authToken = "Run test accounts to set a proper auth token";
myClient.AuthToken = authToken;
await TestAccounts(myClient);
//await TestProjects( myClient );
//await TestClients( myClient );
//await TestComments( myClient );
await TestStreams(myClient);
//await TestObjects( myClient );
Console.WriteLine();
Console.WriteLine("Press any key to close");
Console.ReadLine();
}
/// <summary>
/// Gets a stream and its objects, in bulk. This is NOT recommended for large streams.
/// </summary>
/// <param name="_streamId"></param>
static void GetStream(string _streamId = null)
{
Console.WriteLine("Hello Speckle! We will now try and get a stream.");
var account = LocalContext.GetAccountByEmailAndRestApi("*****@*****.**", "https://hestia.speckle.works/api");
var streamId = "";
if (_streamId == null)
{
Console.WriteLine("What stream id should we get?");
streamId = Console.ReadLine();
}
else
{
streamId = _streamId;
}
var client = new SpeckleApiClient(account.RestApi, false, "console_app");
client.AuthToken = account.Token;
var stream = client.StreamGetAsync(streamId, "").Result.Resource;
var objects = client.StreamGetObjectsAsync(streamId, "fields=hash,type").Result; // restricting to just a few things
Console.WriteLine("This is the stream:");
Console.WriteLine(stream.ToJson());
Console.WriteLine();
Console.WriteLine("Press any key to continue.");
Console.ReadLine();
Console.WriteLine("These are the objects:");
Console.WriteLine(objects.ToJson());
Console.WriteLine();
Console.WriteLine("Press any key to continue.");
Console.ReadLine();
}
public RhinoSender(string _payload, Interop _Context)
{
Context = _Context;
dynamic InitPayload = JsonConvert.DeserializeObject <ExpandoObject>(_payload);
Client = new SpeckleApiClient(( string )InitPayload.account.restApi, true);
StreamName = ( string )InitPayload.streamName;
SetClientEvents();
SetRhinoEvents();
SetTimers();
Display = new SpeckleDisplayConduit();
Display.Enabled = true;
Context.NotifySpeckleFrame("set-gl-load", "", "true");
Client.IntializeSender(( string )InitPayload.account.apiToken, Context.GetDocumentName(), "Rhino", Context.GetDocumentGuid())
.ContinueWith(res =>
{
StreamId = Client.Stream.StreamId;
Client.Stream.Name = StreamName;
Context.NotifySpeckleFrame("set-gl-load", "", "false");
Context.NotifySpeckleFrame("client-add", StreamId, JsonConvert.SerializeObject(new { stream = Client.Stream, client = Client }));
Context.UserClients.Add(this);
InitTrackedObjects(InitPayload);
DataSender.Start();
});
}
/// <summary>
/// Exposed method for users to call when trying to login to a Speckle server via code.
/// </summary>
/// <param name="email">The email of the account you wish to login with.</param>
/// <param name="password">The corresponding password for the account.</param>
/// <param name="callBack">A method callback which takes a <c>User</c>.</param>
/// <returns>An async Task which can be awaited with a coroutine or just ignored.</returns>
/// <remarks>If login was successful, the resulting user object is passed back. If failed, null
/// is passed. Need to be using the <c>SpeckleCore</c> namespace to access this type.</remarks>
public virtual async Task LoginAsync(string email, string password, Action <User> callBack)
{
if (string.IsNullOrWhiteSpace(email) || string.IsNullOrWhiteSpace(password))
{
throw new InvalidOperationException("The email and password arguments both need to be provided if you wish to login.");
}
SpeckleApiClient loginClient = new SpeckleApiClient(serverUrl.Trim());
User user = new User {
Email = email.Trim(), Password = password.Trim()
};
Debug.Log("Atempting login");
ResponseUser userGet = await loginClient.UserLoginAsync(user);
if (userGet == null)
{
Debug.LogError("Could not login");
callBack?.Invoke(null);
}
else
{
loggedInUser = userGet.Resource;
Debug.Log("Logged in as " + loggedInUser.Name + " " + loggedInUser.Surname);
loginClient?.Dispose(true);
callBack?.Invoke(loggedInUser);
}
}
public override bool Read(GH_IReader reader)
{
try
{
var serialisedClient = reader.GetByteArray("speckleclient");
var copy = serialisedClient;
using (var ms = new MemoryStream())
{
ms.Write(serialisedClient, 0, serialisedClient.Length);
ms.Seek(0, SeekOrigin.Begin);
mySender = (SpeckleApiClient) new BinaryFormatter().Deserialize(ms);
var x = mySender;
RestApi = mySender.BaseUrl;
StreamId = mySender.StreamId;
WasSerialised = true;
}
reader.TryGetBoolean("remotecontroller", ref EnableRemoteControl);
reader.TryGetBoolean("manualmode", ref ManualMode);
}
catch (Exception err)
{
throw err;
}
return(base.Read(reader));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
SpeckleApiClient client = null;
var obj = JValue.Load(reader);
try
{
var bytes = (byte[])obj;
if (bytes != null)
{
using (MemoryStream input = new MemoryStream(bytes))
using (DeflateStream deflateStream = new DeflateStream(input, CompressionMode.Decompress))
using (MemoryStream output = new MemoryStream())
{
deflateStream.CopyTo(output);
deflateStream.Close();
output.Seek(0, SeekOrigin.Begin);
BinaryFormatter bformatter = new BinaryFormatter();
client = (SpeckleApiClient)bformatter.Deserialize(output);
}
}
}
catch {
// null/empty receiver
}
return(client);
}
public override object ReadJson(DNJ.JsonReader reader, Type objectType, object existingValue, DNJ.JsonSerializer serializer)
{
// Fixes https://github.com/speckleworks/SpeckleDynamo/issues/61
SpeckleCore.SpeckleInitializer.Initialize();
// Carry on as usual (NOTE: we need to clean this up)
SpeckleApiClient client = null;
var obj = DNJ.Linq.JValue.Load(reader);
try
{
var bytes = (byte[])obj;
if (bytes != null)
{
using (MemoryStream input = new MemoryStream(bytes))
using (DeflateStream deflateStream = new DeflateStream(input, CompressionMode.Decompress))
using (MemoryStream output = new MemoryStream())
{
deflateStream.CopyTo(output);
deflateStream.Close();
output.Seek(0, SeekOrigin.Begin);
BinaryFormatter bformatter = new BinaryFormatter();
client = (SpeckleApiClient)bformatter.Deserialize(output);
client.ClientType = "Dynamo";
}
}
}
catch {
// null/empty receiver
}
return(client);
}
/// <summary>
/// All clients need to be initialized which creates an instance of an internal speckle client object,
/// authenticates against the server and provides a manager object to receive inspector arguments from.
/// </summary>
/// <param name="manager">The manager instance that provides inspector values for this client.</param>
/// <param name="url">The url of the speckle server to connect to.</param>
/// <param name="apiToken">The authentication token of the user to connect as.</param>
/// <returns>An async <c>Task</c> of the new operation.</returns>
public override async Task InitializeClient(SpeckleUnityManager manager, string url, string apiToken)
{
if (streamRoot == null)
{
streamRoot = new GameObject().transform;
streamRoot.name = "Default Stream Root: " + streamID;
}
this.manager = manager;
client = new SpeckleApiClient(url.Trim(), true);
client.BaseUrl = url.Trim();
RegisterClient();
await client.IntializeReceiver(streamID, Application.productName, "Unity", Guid.NewGuid().ToString(), apiToken);
Debug.Log("Initialized stream: " + streamID);
deserializedStreamObjects = new List <object> ();
layerLookup = new Dictionary <Layer, Transform> ();
speckleObjectLookup = new Dictionary <GameObject, SpeckleObject> ();
numbers = new List <float> ();
strings = new List <string> ();
meshes = new List <Mesh> ();
meshRenderers = new List <MeshRenderer> ();
//after connected, call update global to get geometry
await UpdateGlobal();
}
public override bool Read(GH_IReader reader)
{
try
{
Debug.WriteLine("Trying to read client!");
var serialisedClient = reader.GetByteArray("speckleclient");
using (var ms = new MemoryStream())
{
ms.Write(serialisedClient, 0, serialisedClient.Length);
ms.Seek(0, SeekOrigin.Begin);
myReceiver = (SpeckleApiClient) new BinaryFormatter().Deserialize(ms);
StreamId = myReceiver.StreamId;
AuthToken = myReceiver.AuthToken;
RestApi = myReceiver.BaseUrl;
InitReceiverEventsAndGlobals();
}
}
catch
{
Debug.WriteLine("No client was present.");
}
return(base.Read(reader));
}
public override bool Read(GH_IReader reader)
{
try
{
var serialisedClient = reader.GetByteArray("speckleclient");
var copy = serialisedClient;
using (var ms = new MemoryStream())
{
ms.Write(serialisedClient, 0, serialisedClient.Length);
ms.Seek(0, SeekOrigin.Begin);
Client = (SpeckleApiClient) new BinaryFormatter().Deserialize(ms);
Client.ClientType = "Grasshopper";
RestApi = Client.BaseUrl;
StreamId = Client.StreamId;
WasSerialised = true;
}
reader.TryGetBoolean("remotecontroller", ref EnableRemoteControl);
reader.TryGetBoolean("manualmode", ref ManualMode);
reader.TryGetBoolean("DebouncingDisabled", ref DebouncingDisabled);
}
catch (Exception err)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Failed to reinitialise sender.");
}
return(base.Read(reader));
}
private void ChangeStreamId(object sender, System.Timers.ElapsedEventArgs e)
{
Debug.WriteLine("Changing streams to {0}.", StreamId);
Client = new SpeckleApiClient(RestApi, true);
InitReceiverEventsAndGlobals();
Client.IntializeReceiver(StreamId, Document.DisplayName, "Grasshopper", Document.DocumentID.ToString(), AuthToken);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
if (Paused)
{
SetObjects(DA);
return;
}
string inputId = null;
DA.GetData(0, ref inputId);
if (inputId == null && StreamId == null)
{
return;
}
if (inputId != StreamId)
{
Debug.WriteLine("Changing streams: {0} ::> {1}", inputId, StreamId);
StreamId = inputId;
if (myReceiver != null)
{
myReceiver.Dispose(true);
}
myReceiver = new SpeckleApiClient(RestApi, true);
InitReceiverEventsAndGlobals();
myReceiver.IntializeReceiver(StreamId, Document.DisplayName, "Grasshopper", Document.DocumentID.ToString(), AuthToken);
return;
}
if (myReceiver == null)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Receiver not intialised.");
return;
}
if (!myReceiver.IsConnected)
{
return;
}
if (Expired)
{
Expired = false; UpdateGlobal(); return;
}
CalculateBoundingBox();
ExpirePreview(true);
SetObjects(DA);
}
static void Main(string[] args)
{
Console.WriteLine("Hello Smelly Sockets");
SelectedAccount = SpkConsole.Program.GetAccount();
var spkClient_A = new SpeckleApiClient(SelectedAccount.RestApi, false, "console application");
var spkClient_B = new SpeckleApiClient(SelectedAccount.RestApi, false, "console application");
spkClient_A.AuthToken = SelectedAccount.Token;
spkClient_B.AuthToken = SelectedAccount.Token;
//gen streamid
DummyStreamId = spkClient_A.StreamCreateAsync(new SpeckleStream()
{
Name = "WS Test"
}).Result.Resource.StreamId;
Console.WriteLine($"Created dummy stream: {DummyStreamId}. Press any key to continue stuff.");
// Add event handlers and setup streamId on both ws clients. The event handlers just spit out what they get.
spkClient_A.StreamId = DummyStreamId;
spkClient_A.SetupWebsocket();
spkClient_A.OnWsMessage += SpkClient_A_OnWsMessage;
spkClient_B.StreamId = DummyStreamId;
spkClient_B.SetupWebsocket();
spkClient_B.OnWsMessage += SpkClient_B_OnWsMessage;
Console.WriteLine("Waiting for 200ms, ensure connection actually happened. This is an issue with core, it doesn't expose a 'onwsconnection' event :/");
Thread.Sleep(200);
// Flop them in a room - this is important if you want to broadcast messages.
spkClient_A.JoinRoom("stream", DummyStreamId);
spkClient_B.JoinRoom("stream", DummyStreamId);
// Same hack as above.
Thread.Sleep(200);
// Send some dummy broadcasts
spkClient_A.BroadcastMessage("stream", DummyStreamId, new { customEventType = "update-mesh", data = "42" });
spkClient_A.BroadcastMessage("stream", DummyStreamId, new { customEventType = "update-mesh-other", data = "wow" });
spkClient_B.BroadcastMessage("stream", DummyStreamId, new { customEventType = "update-mesh-other", data = "wow" });
spkClient_B.SendMessage(spkClient_A.ClientId, new { what = "This is a direct, 1-1 message from B to A." });
Console.WriteLine("Press any key to continue testing the barebones approach!");
BareBonesApproach();
Console.WriteLine("Done. Press any key to continue.");
spkClient_A.StreamDeleteAsync(DummyStreamId);
Console.ReadLine();
}
/// <summary>
/// Clones the stream.
/// </summary>
/// <param name="restApi">Server address</param>
/// <param name="apiToken">API token for account</param>
/// <param name="streamID">Stream ID of stream to clone</param>
/// <returns>Stream ID of the clone</returns>
public static async Task <string> CloneStream(string restApi, string apiToken, string streamID)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
ResponseStreamClone response = await myClient.StreamCloneAsync(streamID);
return(response.Clone.StreamId);
}
/// <summary>
/// Create SpeckleGSASender object.
/// </summary>
/// <param name="serverAddress">Server address</param>
/// <param name="apiToken">API token</param>
public StreamSender(string serverAddress, string apiToken)
{
this.apiToken = apiToken;
apiClient = new SpeckleApiClient()
{
BaseUrl = serverAddress.ToString()
};
//SpeckleInitializer.Initialize();
LocalContext.Init();
}
/// <summary>
/// Returns streams associated with account.
/// </summary>
/// <param name="restApi">Server address</param>
/// <param name="apiToken">API token for account</param>
/// <returns>List of tuple containing the name and the streamID of each stream</returns>
public static async Task <List <SpeckleStream> > GetStreams(string restApi, string apiToken, ISpeckleAppMessenger messenger)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
var queryString = "limit=500&sort=-updatedAt&parent=&fields=name,streamId,parent";
try
{
ResponseStream response = await myClient.StreamsGetAllAsync(queryString);
List <SpeckleStream> ret = new List <SpeckleStream>();
foreach (SpeckleStream s in response.Resources.Where(r => r.Parent == null))
{
ret.Add(s);
}
return(ret);
}
catch (SpeckleException se)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to access stream list information from the server");
var context = new List <string>()
{
"Unable to access stream list information from the server",
"StatusCode=" + se.StatusCode, "ResponseData=" + se.Response, "Message=" + se.Message, "BaseUrl=" + restApi,
"Endpoint=StreamsGetAllAsync", "QueryString=\"" + queryString + "\""
};
if (se is SpeckleException <ResponseBase> && ((SpeckleException <ResponseBase>)se).Result != null)
{
var responseJson = ((SpeckleException <ResponseBase>)se).Result.ToJson();
context.Add("ResponseJson=" + responseJson);
}
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, se, context.ToArray());
}
}
catch (Exception ex)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to access stream list information from the server");
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, ex, "Unable to access stream list information",
"BaseUrl=" + restApi);
}
}
return(null);
}
public static async Task <SpeckleStream> GetStream(string restApi, string apiToken, string streamId, ISpeckleAppMessenger messenger)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
var queryString = "fields=streamId,name";
try
{
var response = await myClient.StreamGetAsync(streamId, queryString);
if (response != null && response.Success.HasValue && response.Success.Value &&
response.Resource != null && response.Resource.StreamId.Equals(streamId, StringComparison.InvariantCultureIgnoreCase))
{
return(response.Resource);
}
}
catch (SpeckleException se)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to access stream information for " + streamId);
var context = new List <string>()
{
"Unable to access stream information for " + streamId,
"StatusCode=" + se.StatusCode, "ResponseData=" + se.Response, "Message=" + se.Message, "BaseUrl=" + restApi,
"Endpoint=StreamGetAsync", "QueryString=\"" + queryString + "\""
};
if (se is SpeckleException <ResponseBase> && ((SpeckleException <ResponseBase>)se).Result != null)
{
var responseJson = ((SpeckleException <ResponseBase>)se).Result.ToJson();
context.Add("ResponseJson=" + responseJson);
}
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, se, context.ToArray());
}
}
catch (Exception ex)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to access stream information for " + streamId);
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, ex, "Unable to access stream information",
"BaseUrl=" + restApi, "StreamId" + streamId);
}
}
return(null);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
if (Paused)
{
SetObjects(DA);
return;
}
string inputId = null;
DA.GetData(0, ref inputId);
if (inputId == null && StreamId == null)
{
return;
}
if (inputId != StreamId)
{
Client?.Dispose(true);
Client = null;
StreamId = inputId;
StreamIdChanger.Start();
return;
}
if (Client == null)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Receiver not intialised.");
return;
}
if (!Client.IsConnected)
{
return;
}
if (Expired)
{
Expired = false; UpdateGlobal(); return;
}
CalculateBoundingBox();
ExpirePreview(true);
SetObjects(DA);
}
public static async Task <string> GetClientName(string restApi, string apiToken, ISpeckleAppMessenger messenger)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
ResponseUser user = null;
try
{
user = await myClient.UserGetAsync();
}
catch (SpeckleException se)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to get user's name from server");
var context = new List <string>()
{
"Unable to get user's name from server",
"StatusCode=" + se.StatusCode, "ResponseData=" + se.Response, "Message=" + se.Message, "BaseUrl=" + restApi,
"Endpoint=UserGetAsync"
};
if (se is SpeckleException <ResponseBase> && ((SpeckleException <ResponseBase>)se).Result != null)
{
var responseJson = ((SpeckleException <ResponseBase>)se).Result.ToJson();
context.Add("ResponseJson=" + responseJson);
}
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, se, context.ToArray());
return("");
}
}
catch (Exception ex)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to get user's name from server");
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, ex, "Unable to rename stream", "BaseUrl=" + restApi);
return("");
}
}
if (user.Resource != null)
{
return(string.Join(" ", user.Resource.Name, user.Resource.Surname));
}
return("");
}
public static async Task <bool> UpdateStreamName(string restApi, string apiToken, string streamId, string streamName, ISpeckleAppMessenger messenger)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
try
{
var response = await myClient.StreamUpdateAsync(streamId, new SpeckleStream()
{
Name = streamName
});
return(response.Success.HasValue && response.Success.Value);
}
catch (SpeckleException se)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to update stream name for " + streamId);
var context = new List <string>()
{
"Unable to update stream name for " + streamId,
"StatusCode=" + se.StatusCode, "ResponseData=" + se.Response, "Message=" + se.Message, "BaseUrl=" + restApi
};
if (se is SpeckleException <ResponseBase> && ((SpeckleException <ResponseBase>)se).Result != null)
{
var responseJson = ((SpeckleException <ResponseBase>)se).Result.ToJson();
context.Add("ResponseJson=" + responseJson);
}
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, se, context.ToArray());
}
return(false);
}
catch (Exception ex)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to update stream name for " + streamId);
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, ex, "Unable to rename stream", "StreamId=" + streamId, "BaseUrl=" + restApi, "StreamName=" + streamName);
}
return(false);
}
}
/// <summary>
/// Returns streams associated with account.
/// </summary>
/// <param name="restApi">Server address</param>
/// <param name="apiToken">API token for account</param>
/// <returns>List of tuple containing the name and the streamID of each stream</returns>
public static async Task <List <Tuple <string, string> > > GetStreams(string restApi, string apiToken)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
ResponseStream response = await myClient.StreamsGetAllAsync("fields=name,streamId");
List <Tuple <string, string> > ret = new List <Tuple <string, string> >();
foreach (SpeckleStream s in response.Resources)
{
ret.Add(new Tuple <string, string>(s.Name, s.StreamId));
}
return(ret);
}
public void Init(string inStreamID)
{
Client = new SpeckleApiClient(restURL);
//Assign events
Client.OnReady += Client_OnReady;
Client.OnLogData += Client_OnLogData;
Client.OnWsMessage += Client_OnWsMessage;
Client.OnError += Client_OnError;
//make sure convereter is loaded
var hack = new ConverterHack();
SpeckleObjects = new List <SpeckleObject>();
StreamID = inStreamID;
Client.IntializeReceiver(StreamID, "UnityTest", "Unity", "UnityGuid", authToken);
UpdateGlobal();
}
public SpeckleAdapter(SpeckleCore.Account speckleAccount, string speckleStreamId, string speckleStreamName = "Anonymous stream")
{
if (string.IsNullOrWhiteSpace(speckleStreamId))
{
BH.Engine.Reflection.Compute.RecordError("StreamId can't be null or empty.");
return;
}
SpeckleStream SpeckleStream = new SpeckleStream()
{
StreamId = speckleStreamId, Name = speckleStreamName
};
SpeckleClient = new SpeckleApiClient()
{
BaseUrl = speckleAccount.RestApi, AuthToken = speckleAccount.Token, Stream = SpeckleStream, StreamId = SpeckleStream.StreamId
};
SpeckleClient.SetupWebsocket();
}
/// <summary>
/// Clones the stream.
/// </summary>
/// <param name="restApi">Server address</param>
/// <param name="apiToken">API token for account</param>
/// <param name="streamId">Stream ID of stream to clone</param>
/// <returns>Stream ID of the clone</returns>
public static async Task <string> CloneStream(string restApi, string apiToken, string streamId, ISpeckleAppMessenger messenger)
{
SpeckleApiClient myClient = new SpeckleApiClient()
{
BaseUrl = restApi, AuthToken = apiToken
};
try
{
ResponseStreamClone response = await myClient.StreamCloneAsync(streamId);
return(response.Clone.StreamId);
}
catch (SpeckleException se)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to clone stream name for " + streamId);
var context = new List <string>()
{
"Unable to clone stream name for " + streamId,
"StatusCode=" + se.StatusCode, "ResponseData=" + se.Response, "Message=" + se.Message, "BaseUrl=" + restApi,
"Endpoint=StreamCloneAsync"
};
if (se is SpeckleException <ResponseBase> && ((SpeckleException <ResponseBase>)se).Result != null)
{
var responseJson = ((SpeckleException <ResponseBase>)se).Result.ToJson();
context.Add("ResponseJson=" + responseJson);
}
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, se, context.ToArray());
}
}
catch (Exception ex)
{
if (messenger != null)
{
messenger.Message(MessageIntent.Display, MessageLevel.Error, "Unable to clone stream name for " + streamId);
messenger.Message(MessageIntent.TechnicalLog, MessageLevel.Error, ex, "Unable to rename stream", "StreamId=" + streamId, "BaseUrl=" + restApi);
}
}
return("");
}
public RevitReceiver(string payload, Interop parent)
{
Context = parent;
dynamic p = JsonConvert.DeserializeObject(payload);
StreamId = (string)p.streamId;
Client = new SpeckleApiClient((string)p.account.restApi, true);
Client.OnReady += Client_OnReady;
Client.OnLogData += Client_OnLogData;
Client.OnWsMessage += Client_OnWsMessage;
Client.OnError += Client_OnError;
Client.IntializeReceiver((string)p.streamId,
Context.GetDocumentName(),
"Revit",
Context.GetDocumentGuid(),
(string)p.account.apiToken);
Objects = new List <SpeckleObject>();
}
public RhinoReceiver(string _payload, Interop _parent)
{
Context = _parent;
dynamic payload = JsonConvert.DeserializeObject(_payload);
StreamId = ( string )payload.streamId;
Client = new SpeckleApiClient(( string )payload.account.restApi, true);
Client.OnReady += Client_OnReady;
Client.OnLogData += Client_OnLogData;
Client.OnWsMessage += Client_OnWsMessage;
Client.OnError += Client_OnError;
Client.IntializeReceiver(( string )payload.streamId, Context.GetDocumentName(), "Rhino", Context.GetDocumentGuid(), ( string )payload.account.token);
Display = new SpeckleDisplayConduit();
Display.Enabled = true;
Objects = new List <SpeckleObject>();
}
public override bool Read(GH_IReader reader)
{
try
{
var serialisedClient = reader.GetByteArray("speckleclient");
var copy = serialisedClient;
using (var ms = new MemoryStream())
{
ms.Write(serialisedClient, 0, serialisedClient.Length);
ms.Seek(0, SeekOrigin.Begin);
mySender = (SpeckleApiClient) new BinaryFormatter().Deserialize(ms);
var x = mySender;
RestApi = mySender.BaseUrl;
StreamId = mySender.StreamId;
}
}
catch (Exception err)
{
throw err;
}
return(base.Read(reader));
}
